Javaday27 线程相应的状态和练习

1、线程

1.1、线程状态

状态描述和解释如下：

线程状态	名称	描述
NEW	新建	线程刚被创建，还没调用start方法，或者刚刚调用了start方法，调用start方法不一定"立即"改变线程状态，中间可能需要一些步骤才完成一个线程的启动。
RUNNABLE	可行	start方法调用结束,线程由NEW变成RUNNABLE，线程存活着，并尝试抢占CPU资源，或者已经抢占到CPU资源正在运行，这俩种情况的状态都显示为RUNNABLE
BLOCKED	锁阻塞	线程A和线程B都要执行方法test，而且方法test被加了锁，线程A先拿到了锁去执行test方法，线程B这时候需要等待线程A把锁释放。这时候线程B就是处理BLOCKED
WAITING	无限期等待	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
TIMED_WAITING	有限期等待	和WAITING状态类似，但是有一个时间期限，时间到了，自己也会主动醒来
TERMINATED	终止（死亡）	run方法执行结束的线程处于这种状态。

BLOCKED，WAITING，TIMED_WAITING ，这三种都是线程阻塞状态，只是触发的条件不同，以及从阻塞状态中恢复过来的条件也不同

阻塞状态之下

• 线程不执行代码
• 线程也不参与CPU时间片的争夺

一个线程，没有阻塞状态之下的生命周期：

1. 线程刚创建还没有调用start方法，此时线程处于NEW状态
2. 线程启动之后进入RUNNABLE状态
   • 就绪状态：此时的线程还没有运行，正在抢夺CPU的执行权
   • 运行状态：此时的线程正在运行
3. 线程在经过多次CPU的抢夺，最终将run方法执行完毕，之中变成了TERMINATED状态

死亡后的线程，不能重新启动

NEW-----start()---->RUNNABLE<------>调度>-----<时间片结束<—>(RUNNABLE)RUNNING--------run方法结束------->Dead

从就绪状态到运行状态，之间会经过多次反复的CPU执行权的争夺（线程调度）

1.2、sleep方法

sleep方法是Thread中的一个静态方法，作用是让当前执行的线程暂时休眠指定的毫秒数：

一个线程中如果sleep方法，那么这个线程就会进入到TIMED_WAITING状态------阻塞状态

TIMED_WAITING状态在阻塞结束之后，线程会自动回到RUNNABLE状态

此时的状态图为：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YS9UjPeZ-1598887758919)(D:/briup-java/corejava-day19/note/day19/corejava-day19.assets/image-20200812155823706.png)]

1.3、join方法

线程类中的Thread中的join方法，是非静态final修饰的方法，需要通过对象进行访问，并且不可重写

使用join方法，可以让当前线程阻塞，等待另一个指定的线程运行结束后，当前线程才可以继续运行：

使用join的无参方法后，会让线程从RUNNABLE状态进入到WAITING状态，处于这个状态之下，需要另外一个线程唤醒它，才会从WAITING状态变为RUNNABLE状态

这个状态之下，需要等指定线程结束之后，才会醒过来

如果使用的是joid的有参方法，会让线程从RUNNABLE状态进入到TIMED_WAITING状态。（该方法类似于sleep方法）

这个状态下，需要等到joid指定的时间结束，就会自动醒过来

此时的状态图为：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZkssbAW9-1598887758924)(D:/briup-java/corejava-day19/note/day19/corejava-day19.assets/image-20200812163351976.png)]

• 如果指定了时间，线程阻塞一定的时间后，会自动恢复到RUNNABLE状态，这种情况下，线程的状态为TIMED_WAITING（有限期等待）
• 如果没有指定时间，线程会一直阻塞着，直到某个条件满足时，才会自动恢复，这种情况下，线程的状态为WAITING（无限期等待）

1.4、interrupt

在我们使用sleep和joid方法的时候，都需要我们抛出InterruptedException类型的异常，说明调用sleep和join使线程进入阻塞状态的情况下，是有可能抛出InterruptedException类型的异常的

InterruptedException异常类型指的是：线程A中，调用了线程B的interrupt方法，而此时线程B处于阻塞状态，那么此时sleep方法或者join方法就会抛出被打断的异常

当我们在其他线程中调用其他线程的interrupt方法，会打断那个线程的阻塞状态，此时阻塞状态会解除，并抛出一个被打断的异常

此时对于的流程图为：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nRPnxsE9-1598887758927)(D:/briup-java/corejava-day19/note/day19/corejava-day19.assets/image-20200812173258437.png)]

interrupt方法的工作原理：

interrupt方法时通过改变线程对象中的一个标识值（true|false），来达到打断阻塞状态的效果

一个线程在阻塞状态下，会时刻检测这个标识的值是不是true，如果一旦发现这个值变为true，那么就会抛出异常结束阻塞状态，再将这个值改为false

在默认情况之下，一个线程对象中的“打断标识”值为false

无论线程是否处于阻塞状态，其他线程都可以调用这个线程的interrupt方法，因为该方法只是改变线程对象中“打断标识”值而已

可以通过其他方法查看线程对象中“打断标识”值

• isInterrupted方法

  这个非静态方法，只是返回这个“打断标识”值，并且不会对这个值进行清除（true->false），简单来说就是这个方法只会返回当前这个标识值为多少，并不会对这个标识值做出任何改变

• interrupted方法

  这个静态方法，返回这个“打断标识”值，并且会对这个值进行清除（true->false），简单来说就是这个方法不仅会返回标识值，还会对标识值进行修改

三者的区别：

1. interrupt()用来设置线程的中断状态，能够抛出InterruptedException的阻塞方法+中断状态会抛出异常并清除线程的中断状态。
2. interrupted()和isInterrupted()调用完后，前者会清除中断状态，而后者则保留中断状态。

1.5、线程安全和线程同步

线程安全

JVM内存中的堆区，是一个线程共享的区域，是所有线程都可以访问的内存空间

JVM内存中的栈区，是每个线程私有的空间，无法访问其他栈区的数据

在多个线程环境下，如果有两个线程并发范围跟同一个堆区中一个对象中的数据，并执行写操作，那么这个数据最终的结果可能会出现与预期不符合的情况，这种情况就是线程安全问题

线程同步

当使用多个线程访问同一个共享变量的时候，并且线程中对变量有写的操作，这时就容易出现线程安全问题。

Java中提供了线程同步的机制，来解决上述的线程安全问题。

Java中实现线程同步的方式，是给需要同步的代码进行**synchronized关键字加锁。**

我们以A、B两个线程访问同一个堆区变量为例，

在没有加锁的情况之下，这就存在着线程安全问题，

当我们使用同一个锁对象对两个线程中的指定代码进行上锁，线程必须要拿到锁才可以执行指定的代码，假如A线程拿到锁，那么B线程必须等到A线程执行玩被锁住的代码，才可以拿到锁。这种情况就不会出现同时访问共享变量执行写操作的线程安全问题。

这里值得注意的时，当A线程拿到锁的时候，B线程也会区抢占CPU，只不过就算B抢到了CPU也因为没有锁，只能让出CPU，自己就会进入阻塞状态。

此时的阻塞状态，与之前sleep和join的阻塞状态不同，这种阻塞状态需要一个锁对象可用的时候，才回去解除这种阻塞状态。

这种阻塞状态为：BLOCKED

锁其实就是将指定的执行代码放到锁中才可以执行这部分代码，当锁中有代码要执行，那么其他线程的代码就不能进入到这个锁中，只有当这个锁中的代码执行完毕，并清除锁中的代码，其他线程的代码才可以进入锁中

锁对象可以时任意的一个对象。

此时的线程状态图为：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R6BWNNQ8-1598887758930)(D:/briup-java/corejava-day19/note/day19/corejava-day19.assets/image-20200813000218179.png)]

1.6、synchronized

synchronized修饰一个代码块，并指定谁是锁对象的用法，除此之外，还可以使用synchronized直接修饰一个方法，表示这个方法中的所有代码都需要线程同步。

• synchronized关键字修饰非静态方法，默认使用this当做锁对象，并且不能自己另外指定

• synchronized关键字修饰静态方法，默认使用当前类的Class对象当做锁对象，并且不能自己另外指定

1.7、wait和notify

Object类中有三个方法：wait()、notify()、notifyAll

当一个对象，在线程同步的代码中，充当锁对象的时候，在synchronized同步的代码块中，就可以调用这个锁对象的这三个方法了。

三个核心点：

• 任何对象中都一定有这三个方法
• 只有对象作为锁对象的时候，才可以调用
• 只有在同步的代码块中，才可以调用

其他情况下，调用一个对象的这三个方法，都会报错！

wait()方法会将锁立即释放

当通过wait()方法将锁释放，那么这个线程就会进入等待池，并且处于阻塞状态—WAITING

此时需要等待同步线程中的其他线程将其唤醒，不然就会一致处于WAITING状态

notify()方法可以随机将等待池中一个待唤醒的线程随机唤醒一个，并且这个线程就会从等待池进入到锁池，而进入到锁池的线程，会时刻关注锁对象是否可用，一旦可用，这个线程就会立刻自动恢复到RUNNABLE状态

而notifyAll()会将等待池中的线程全部唤醒

使用interrupt（）方法也可以使得某一个线程从等待池中进入锁池

此时线程的状态图为：

WAITING状态

notify()方法可以随机将等待池中一个待唤醒的线程随机唤醒一个，并且这个线程就会从等待池进入到锁池，而进入到锁池的线程，会时刻关注锁对象是否可用，一旦可用，这个线程就会立刻自动恢复到RUNNABLE状态

而notifyAll()会将等待池中的线程全部唤醒

使用interrupt（）方法也可以使得某一个线程从等待池中进入锁池

此时线程的状态图为：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OwnNWztz-1598887758931)(D:/briup-java/corejava-day19/note/day19/corejava-day19.assets/image-20200813023535119.png)]

public class TwoLock {
	@SuppressWarnings({"rawtypes" })
	public static void main(String[] args) {
		Class in =int.class;
		Class ob =Object.class;
		ThreadGroup group = new ThreadGroup("T-one组");
		new Thread(group,new Runnable() {
			@Override
			public void run() {
				synchronized (ob) {
					synchronized (in) {
						for(int a = 100;a >= 0;a--) {
							System.out.println(Thread.currentThread().getName()+":"+a);
						}
					}
				}
			}
		},"A线程").start();
		new Thread(group,new Runnable() {
			@Override
			public void run() {
				synchronized (in) {
					for(int a = 100;a >= 0;a--) {
						System.out.println(Thread.currentThread().getName()+":"+a);
					}
				}
			}
		},"B线程").start();
		new Thread(group,new Runnable() {
			@Override
			public void run() {
				// TODO Auto-generated method stub
				synchronized (ob) {
					synchronized (in) {
						for(int a = 100;a >= 0;a--) {
							System.out.println(Thread.currentThread().getName()+":"+a);
						}	
					}
				}
			}
		},"C线程").start();
	}
}

使用两个锁实现三个线程按次序输出

public class Multithreading {
	public static int flag = 1;
	public static void main(String[] args) {
		ThreadGroup group = new ThreadGroup("T-one线程");
		new Thread(group,new Runnable() {

			@Override
			public void run() {
				synchronized (int.class) {
					for(int a = 97;a <= 122;a++) {
						if(flag != 1) {
							a--;
							int.class.notifyAll();
							try {
								int.class.wait();
							} catch (InterruptedException e) {
								// TODO Auto-generated catch block
								e.printStackTrace();
							}
						}else {
							System.out.println(Thread.currentThread().getName()+":"+(char)a);
							flag ++;
						}
						
					}
					
				}

			}
		},"A线程").start();
		new Thread(group,new Runnable() {

			@Override
			public void run() {
				synchronized (int.class) {
					for(int a = 97;a <= 122;a++) {
						if(flag != 2) {
							a--;
							int.class.notifyAll();
							try {
								int.class.wait();
							} catch (InterruptedException e) {
								// TODO Auto-generated catch block
								e.printStackTrace();
							}
						}else {
							System.out.println(Thread.currentThread().getName()+":"+(char)a);
							flag++;
						}
						
					}
					int.class.notify();
				}

			}
		},"B线程").start();
		new Thread(group,new Runnable() {

			@Override
			public void run() {
				synchronized (int.class) {
					for(int a = 97;a <= 122;a++) {
						if(flag != 3) {
							int.class.notifyAll();
							a--;
							try {
								int.class.wait();
							} catch (InterruptedException e) {
								// TODO Auto-generated catch block
								e.printStackTrace();
							}
						}else {
							System.out.println(Thread.currentThread().getName()+":"+(char)a);
							flag -=2;
						}
						
					}
				}

			}
		},"C线程").start();
	}
}

三个线程依次交替输出

public class Test {
	public static boolean falg= false;
	public static void main(String[] args) {
		
		
		Thread t1 = new Thread(new Runnable() {
			
			@Override
			public  void run() {
				synchronized (int.class) {
					for (int i = 1; i <= 100; i++) {
						if(falg!=true) {
							int.class.notify();
							i -= 1;
							try {
								int.class.wait();
							} catch (InterruptedException e) {
								// TODO Auto-generated catch block
								e.printStackTrace();
							}
						}else {
							System.out.println(Thread.currentThread().getName()+":"+i);
							falg =!falg;
						}
						int.class.notify();
					}
				}
			} 
		},"A");
		Thread t2 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				synchronized (int.class) {
					for (int i = 1; i <= 100; i++) {
						if(falg!=false) {
							int.class.notify();
							i -= 1;
							try {
								int.class.wait();
							} catch (InterruptedException e) {
								// TODO Auto-generated catch block
								e.printStackTrace();
							}
						}else {
							System.out.println(Thread.currentThread().getName()+":"+i);
							falg =!falg;
						}
						int.class.notify();
					}
				}
			}
		},"B");
		t1.start();
		t2.start();
	}
}

两个线程依次交替输出