线程状态切换

线程状态切换

线程从创建并启动到消亡共经历了5种状态：新建、就绪、运行、阻塞和死亡

线程变化的5状态转换：

1、新建状态(New)：新创建了一个线程对象。new Thread()

2、就绪状态(Runnable)：线程对象创建后，其它线程调用了该对象的start()方法。只能针对处于新建状态的 线程对象调用start方法，否则IllegalThreadStateException

该状态的线程位于可执行线程池中，变得可执行，等待获取CPU的使用权。

3、执行状态(Running)：就绪状态的线程获取了CPU。执行程序代码。注意在一个多处理器的机器上会有多个 线程并行执行

现在大部分桌面和服务器操作系统都采用时间片轮转法的抢占式调度策略，在选择下一个执行线程时系统会考虑线 程的优先级

调用yield方法可以让运行状态的线程转入就绪

4、堵塞状态(Blocked)：堵塞状态是线程由于某种原因放弃CPU使用权。临时停止执行。直到线程进入就绪状 态，才有机会转到执行状态。线程切换是由底层平台控制的，具有一定的随机性

堵塞的情况分三种：

(一)、等待堵塞：执行的线程执行wait()方法，JVM会把该线程放入等待池中。

(二)、同步堵塞：执行的线程在获取对象的同步锁时，若该同步锁被别的线程占用。则JVM会把该线程放入锁 池中。

(三)、其它堵塞：执行的线程执行sleep()或join()方法，或者发出了I/O请求时。JVM会把该线程置为堵塞状态。 当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完成时。线程又一次转入就绪状态。

5、死亡状态(Dead)：线程运行完了或者因异常退出了run()方法，该线程结束生命周期。

直接调用该线程的stop方法也可以结束线程，但是这个方法容易导致数据不一致的问题，通常不推荐使用

当主线程结束时，其它线程不受任何影响，并不会随之结束，一旦子线程启动后则拥有和主线程相同的地位，并不受主线程的影响

注意：不要试图对一个已经死亡的线程调用start方法使其重新启动，该线程将不可再次作为线程执行，否则异常

常见问题

• 如何强制启动一个线程
  在Java里面没有办法强制启动一个线程，它是被线程调度器控制着且Java没有公布相关的API
• 垃圾回收
  System.gc()或者Runtime.getRuntime().gc()可以通知进行垃圾回收，但是垃圾回收是一个低优先级线程，具体运 行时间无法预知
• 不再推荐使用的方法
  不要用stop方法来停止一个线程。因为stop方法太极端，会出现同步问题，使数据不一致。所以可以考虑通过设置 标志，通过return， break，异常等手段来控制流程自然停止

Thread t1=new Thread(() -> {
    
     
		for(int i=0;i<100;i++) 
			System.out.println(Thread.currentThread()+"--"+i); 
		}); 
	t1.start(); 
	TimeUnit.MICROSECONDS.sleep(10); 
	t1.stop(); 
	
	//可以通过其它方式实现线程的停止 
	class MyThread extends Thread {
    
     
		private boolean flag = true; 
		@Override 
		public void run() {
    
     
			for (int i = 0; i < 100 && flag; i++) 
				System.out.println(Thread.currentThread() + "--" + i); 
		}
		public void setFlag(boolean flag) {
    
     
			this.flag = flag; 
		} 
	}

suspend()方法用于暂停线程的执行，该方法容易导致死锁，因为该线程在暂停的时候仍然占有该资源，这会导致 其他需要该资源的线程与该线程产生环路等待，从而造成死锁 resume()方法用于恢复线程的执行。suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的 resume() 被调用，才能使得线程重新进入可执行状态

sleep方法使得当前线程休眠

Thread类中定义的

public static native void sleep(long millis)throws InterruptedException

让当前线程休眠指定时间。休眠时间的准确性依赖于系统时钟和CPU调度机制。如果需要可以通过调用interrupt() 方法来唤醒休眠线程

public void interrupt(){
    
    
	if(this!=Thread.currentThread())
		checkAccess();
	synchronized(blockerLock){
    
    
		Interruptible b=blocker;
		if(b!=null){
    
    
			interrupt0();
			b.interrupt(this);
			return;
		}
	}
	interrupt0();
}

不释放已获取的锁资源，如果sleep方法在同步上下文中调用，那么其他线程是无法进入到当前同步块或者同步方 法中的。

练习：实现一个时间显示:每隔一秒钟更新一次(例如倒计时)

自定义格式的时间显示 DateFormat---SimpleDateFormat 
DateFormat df=new SimpleDateFormat("yyyy-MM-ddE hh:mm:ss"); 
for (;;) {
    
     //相当于while(true){} 
	Date now = new Date(); 
	System.out.println(df.format(now)); 
	try {
    
    
		Thread.sleep(1000); 
	} catch (InterruptedException e) {
    
    
		e.printStackTrace(); 
	} 
}

当线程进入休眠态，它会定时结束休眠。如果需要提前唤醒，则需要通过interrupt方法实现。所谓的interrupt方 法实际上会产生一个异常InterruptedException

public static void main(String[] args) throws Exception {
    
    
	DateFormat df = new SimpleDateFormat("yyyy-MM-ddE hh:mm:ss");
	Thread t1 = new Thread(() -> {
    
    
		while (true) {
    
    
			Date now = new Date();
			System.out.println(df.format(now));
			try {
    
     // TimeUnit.SECONDS.sleep(10);
				Thread.sleep(10000);// 子线程进入休眠阻塞状态,当超时后自动进入就绪状态，等待下次 调度执行
			} catch (InterruptedException e) {
    
    
				e.printStackTrace();
			}
		}
	});
	t1.start();
	Thread.sleep(200);
	t1.interrupt(); // 唤醒处于休眠状态的线程，在子线程中会导致InterruptedException
	System.out.println("main.....");
}

wait(Object中定义的)

• wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。直到其他线程调 用此对象的 notify() 方法或 notifyAll()方法，当前线程被唤醒，进入就绪状态
• notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，而notifyAll()是唤醒 所有的线程。
• wait(long timeout)让当前线程处于“等待(阻塞)状态”，“直到其他线程调用此对象的notify()方法或 notifyAll() 方法，或者超过指定的时间量”，当前线程被唤醒(进入“就绪状态”)。

让当前线程进入等待状态，当别的其他线程调用notify()或者notifyAll()方法时，当前线程进入就绪状态

wait方法必须在同步上下文中调用，例如：同步方法块或者同步方法中，这也就意味着如果你想要调用wait方法， 前提是必须获取对象上的锁资源

当wait方法调用时，当前线程将会释放已获取的对象锁资源，并进入等待队列，其他线程就可以尝试获取对象上的锁资源

// 创建锁对象，保证唯一性
Object obj = new Object();
new Thread() {
    
    
	public void run() {
    
    
		// 保证等待和唤醒只能执行一个，需要使用同步技术
		synchronized (obj) {
    
    
			System.out.println("点外卖");
			// 调用wait方法，放弃CPU的执行权，进入WAITING状态（无限等待）
			obj.wait(1000);
			// 唤醒之后的代码
			System.out.println("外卖已到达");
		}
	}
}.start();

sleep vs wait

	wait	sleep
同步	只能在同步上下文中调用wait方法，否则抛出 IllegalMonitorStateException	不需要在同步方法或同步块中调 用
作用对象	wait方法定义在Object类中，作用于对象本身	sleep方法定义在Thread中，作用 于当前线程
释放锁资源	是	否
唤醒条件	其他线程调用对象的notify()或者notifyAll()方法	超时或者调用interrupt()方法体
方法属性	wait是实例方法	sleep是静态方法

Java程序中wait 和 sleep都会造成某种形式的暂停，它们可以满足不同的需要。wait()方法用于线程间通信，如果 等待条件为真且其它线程被唤醒时它会释放锁，而sleep()方法仅仅释放CPU资源或者让当前线程停止执行一段时 间，但不会释放锁。

join方法

主要作用是同步，它可以使得线程之间的并行执行变为串行执行。在A线程中调用了B线程的join()方法时，表示只 有当B线程执行完毕时，A线程才能继续执行。调用这个方法的线程将被阻塞

• 方法join(long)的功能在内部是使用wait(long)方法来实现的，所以join(long)方法具有释放锁的特点。但是 sleep(long)不释放锁。

练习：编写10个线程，第一个线程从1加到10，第二个线程从11加到20…第十个线程从91加到100，最后再把十个 线程结果相加

使用Callable接口，因为future.get()可以阻塞当前线程的执行

FutureTask[] fs = new FutureTask[10];
for (int i = 0; i < 10; i++) {
    
    
	fs[i] = new FutureTask<>(new MyCallable(i * 10 + 1, (i + 1) * 10));
	new Thread(fs[i]).start();
}
int res = 0;
for (FutureTask ft : fs)
	res += (Integer) ft.get();
System.out.println(res);

使用Runnable接口，必须通过join使子线程执行结束后才在主线程中累加10个子线程的结果

MyRunnable[] arr = new MyRunnable[10];
		Thread[] ts = new Thread[10];
		for (int i = 0; i < 10; i++) {
    
    
			MyRunnable mr = new MyRunnable(i * 10 + 1, (i + 1) * 10);
			arr[i] = mr;
			ts[i] = new Thread(mr);
			ts[i].start();
		}
		int res = 0;
		for (int i = 0; i < 10; i++) {
    
    
			ts[i].join();
			res += arr[i].getRes();
		}
		System.out.println("计算结果为：" + res);