进程，线程相关概念的介绍线程的基本使用
创建线程的两种方式
继承Thread类实现了Runnable接口 线程的终止线程中断线程的插队守护线程线程的7大状态线程同步机制互斥锁死锁释放锁的情况
进程，线程相关概念的介绍1.进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的内存空间。
2.进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程:有它自身的产生、存在和消亡的过程
线程是由进程创建的，是进程的一个实体，一个进程可以拥有多个线程
1.单线程:同一个时刻，只允许执行一个线程
2.多线程:同一个时刻，可以执行多个线程，比如:一个qq进程，可以同时打
开多个聊天窗口,一个迅雷进程,可以同时下载多个文件
3.并发:同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说,单核cpu实现的多任务就是并发。
4.并行:同一个时刻，多个任务同时执行。多核cpu可以实现并行。
一台电脑内可能既存在并发也存在并行。
1.继承Thread类，重写run方法。
2.实现Runnable接口，重写run方法。
run方法实际上是Runnable中声明的一个方法。
main线程打印hi,Thread-0线程打印hello
public class thread01 {
public static void main(String[] args) throws InterruptedException {
Cat cat = new Cat();
cat.start();//启动线程，最终会执行run()方法
System.out.println("main线程执行"+Thread.currentThread().getName());
for(int i = 0;i<10;i++){
Thread.sleep(1000);
System.out.println("hi"+(i+1));
}
}
}
//当一个类继承了 Thread 类， 该类就可以当做线程使用
class Cat extends Thread{
@Override
public void run() {
int times = 0;
while (true){
System.out.println("hello"+(++times)+Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(times==10) break;
}
}
}
实现了Runnable接口这个进程中有两个线程，一个主线程-- main 线程，一个main线程创建的子线程Thread-0,当 main 线程启动一个子线程 Thread-0, 主线程不会阻塞, 会继续执行,这时 主线程和子线程是并行。
真正实现多线程的是start0方法，不是run方法
java是单继承的，在某些情况下一个类可能已经继承了某个父类,这时在用继承Thread类方法来创建线程显然不可能了。
java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程
public class Thread02 {
public static void main(String[] args) {
Dog dog = new Dog();
//此时不能直接调用start(),需要先进行处理一下
//这里面用到了代理模式
Thread thread = new Thread(dog);
thread.start();
}
}
class Dog implements Runnable{
@Override
public void run() {
int count = 0;
while (true){
System.out.println("汪汪"+(++count)+Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(count==10) break;
}
}
}
这两种方法并没有明显的差距，但是实现Runnable接口的方法可以实现多继承，同时也有多个线程共享一个资源的情况，因此建议使用这个方法。
T3 t3 = new T3(); Thread thread1 = new Thread(t3); Thread thread2 = new Thread(t3);线程的终止
线程如果自动运行完就会结束它的声明周期，还可以使用控制变量让线程退出run方法来终止线程。
public class ExitThread {
public static void main(String[] args) throws InterruptedException {
T t = new T();
t.start();
Thread.sleep(10*1000);
t.setBool(false);
}
}
class T extends Thread{
private boolean bool = true;
@Override
public void run() {
while(bool){
System.out.println("T 线程在运行~~");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void setBool(boolean bool) {
this.bool = bool;
}
}
线程中断
public class MethodThread {
public static void main(String[] args) throws InterruptedException {
AA aa = new AA();
aa.start();
Thread.sleep(2000);
aa.interrupt();
}
}
class AA extends Thread{
@Override
public void run() {
while (true){
for(int i = 0;i<10;i++){
System.out.println("hello"+(i+1));
}
try {
System.out.println("线程处于休眠状态");
Thread.sleep(20000);
} catch (InterruptedException e) {
System.out.println("线程被中断");
}
}
}
}
在第一次输出hello十次之后，不会休眠20秒，在进行下一次的输出，主线程休眠两秒后，对Thread-0进行中断，让它从休眠中唤醒，它会进行下一次的输出。
线程的插队有两种方法：
1.Thread的静态方法，Thread.yield ： 线程的礼让，让出CPU，让其他线程先执行，因为礼让的时间不确定，因此不一定礼让成功。
2.join : 线程的插队，插队的线程一旦插入成功，那么会将插队的线程的任务先执行完毕，在返回调用join方法的线程。
public class MethodThread02 {
public static void main(String[] args) throws InterruptedException {
A a = new A();
a.start();
for (int i = 0; i < 20; i++) {
Thread.sleep(1000);
System.out.println("主线程执行了" + i + "次");
if(i == 5){
System.out.println("子线程先执行，主线程暂时不执行");
a.join();
//Thread.yield();
System.out.println("主线程继续执行");
}
}
}
}
class A extends Thread{
@Override
public void run() {
for (int i = 0; i < 20; i++) {
try {
Thread.sleep(500);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println("子线程执行" + i +"次");
}
}
}
守护线程
用户线程：也叫工作线程，线程的任务执行完结束或者以通知方式结束。
守护线程： 一般是为了工作线程服务的，当所有的工作线程结束后，守护线程自动结束，常见的守护线程：垃圾回收机制
public class MethodThread03 {
public static void main(String[] args) throws InterruptedException {
MyDameonThread myDameonThread = new MyDameonThread();
myDameonThread.setDaemon(true);//将某个线程设置为守护线程
myDameonThread.start();
for (int i = 0; i < 10; i++) {
System.out.println("工作线程执行" + i + "次");
Thread.sleep(1000);
}
}
}
class MyDameonThread extends Thread{
@Override
public void run() {
for ( ; ;){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("守护线程继续执行");
}
}
}
线程的7大状态
public class state_ {
public static void main(String[] args) throws InterruptedException {
T1 t1 = new T1();
System.out.println(t1.getName() + " 状态 " + t1.getState());
t1.start();
while(Thread.State.TERMINATED != t1.getState()){//只要t1的状态未终止，就一直输出
Thread.sleep(500);
System.out.println(t1.getName() + " 状态 " + t1.getState());
}
System.out.println(t1.getName() + " 状态 " + t1.getState());
}
}
class T1 extends Thread{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("hi" + i);
}
}
}
线程同步机制
在多线程编程中，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。
两种同步方式：
1.同步代码块：synchronized(对象){ }//得到对象的锁，才能操作同步代码
2.synchronized还可以放在方法声明中，表示整个方法为同步方法。
public synchronized void m ( ){ }
死锁1.Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
2.每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
3.关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时,表明该对象在任一时刻只能由一个线程访问
4.同步的局限性:导致程序的执行效率要降低
5.同步方法(非静态的)的锁可以是this,也可以是其他对象(要求是同一个对象)
6.同步方法(静态的)的锁为当前类本身。类.class
多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程时一定要避免死锁的发生。
释放锁的情况1.当前线程的同步方法、同步代码块执行结束
案例:上厕所，完事出来
2.当前线程在同步代码块、同步方法中遇到break、return。
案例:没有正常的完事，经理叫他修改bug,不得已出来
3.当前线程在同步代码块、同步方法中出现了未处理的Error或Exception, 导致异常结束
案例:没有正常的完事，发现忘带纸，不得已出来
4.当前线程在同步代码块、同步方法中执行了线程对象的wait(）方法，当前线程暂停，并释放锁。
案例:没有正常完事，觉得需要酝酿下，所以出来等会再进去
不释放锁的情况:
1.线程执行同步代码块或同步方法时，程序调用Thread.sleep(),Thread.yield()方法暂停当前线程的执行，不会释放锁
案例:上厕所，太困了，在坑位上眯了一会
2.线程执行同步代码块时，其他线程调用了该线程的suspend(方法将该线程挂起，该线程不会释放锁。
提示:应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用
