Java中多线程详解（二）

最新推荐文章于 2021-12-21 10:20:09 发布

罗卜丝粉

最新推荐文章于 2021-12-21 10:20:09 发布

阅读量512

点赞数 1

分类专栏：多线程详解文章标签：多线程 wait sleep notify

本文链接：https://blog.csdn.net/zouxucong/article/details/54290034

版权

多线程详解专栏收录该内容

8 篇文章 1 订阅

订阅专栏

四、线程状态转换

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

2、就绪状态：Runnable,线程对象创建后，其他线程调用了该对象的start()方法，该状态线程位于可运行线程池中，可运行，等待获取CPU的使用权

3、运行状态：running，就绪状态的线程获取了CPU，执行程序代码

4、阻塞状态：blocked，阻塞状态是因为线程由于某种原因放弃CPU使用权，暂时停止运行，直至线程进入就绪状态，才有机会转到运行状态，阻塞的情况分三种：

1）等待阻塞：运行的线程执行wait()方法，JVM把该线程放入等待池中，wait会释放持有的锁

2）同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM把线程放入锁池中

3）其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把线程设置为阻塞状态，当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态（sleep是不会释放持有的锁）

5、死亡状态：dead，线程执行完毕或者因为异常原因退出run()方法，该线程结束生命周期

五、线程调度

1、调整线程优先级：java线程有优先级，优先级高的线程会先获得运行

线程有两种调度模型：分时调度模型和抢占式调度模型

分时调度模型是指让所有的线程轮流获得CPU的使用权，并且平均分配每个线程占用CPU的时间片

JVM采用抢占式调度模型，是指优先让可运行池中优先级高的线程占用CPU，如果可运行池中线程的优先级相同，则随机选择一个线程占用CPU。出于运行状态的线程会一直占用CPU，直至它不得不放弃CPU

线程的优先级用整数表示，取值范围是1~10，Thread有以下三个静态常量：

static int MIN_PRIORITY：线程可以有的最低优先级，取值为1

static int MAX_PRIORITY：线程可以有的最高优先级，取值为10

static int NORM_PRIORITY：线程默认的优先级，取值为5

在Thread类中，用setPriority()和getPriority()分别来设置优先级数值和获取线程的优先级。

线程的优先级有继承关系，比如A线程中创建了B线程，那么A线程和B线程具有相同的优先级

2、放弃CPU的原因

一个线程会因为以下原因放弃CPU：

1）JVM虚拟机让当前线程暂时放弃CPU，转到就绪状态，使其它线程获得运行的机会

2）当前线程因为某些原因而进入阻塞状态

3）线程技术运行

需要注意的是，线程的调度不是跨平台的，它不仅仅取决于JVM，还依赖于操作系统，在某些操作系统中，只要运行的线程没有遇到阻塞，就不会放弃CPU，在某些操作系统中，即使线程没有遇到阻塞，也会运行一段时间后放弃CPU，给其他线程运行的机会。

java的线程调度是不分时的，同时启动多个线程后，不能保证各个线程轮流获得均等的CPU时间片

如果希望明确让一个线程给另一个线程运行的机会，可以采取以下办法之一：

1）调整各个线程的优先级

2）让处于运行状态的线程调用Thread.sleep()方法

3）让处于运行状态的线程调用Thread.yield()方法

4）让处于运行状态的线程调用另一个线程的join()方法

线程切换，不是所有的线程切换都需要进入内核模式

3、线程唤醒

Object类中的notify()方法，唤醒在此对象监视器上等待的单个线程，如果所有线程都在此对象上等待，则会任意选择唤醒其中的一个，并在对实现做出决定时发生。线程通过调用其中一个wait方法，在对象的监视器上等待。直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程发生竞争；例如，被唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势，类似的方法还有一个notifyAll(),唤醒在此对象监视器上等待的所有线程。

六、常用函数说明

①sleep(long millis): 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
②join():指等待t线程终止。

join是Thread类的一个方法，启动线程后直接调用，即join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。

Thread t = new AThread(); t.start(); t.join();

为什么要用join()方法？在很多情况下，主线程生成并启动子线程，如果子线程要进行大量的耗时运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他事务后，需要用到子线程处理的结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。

public class JoinTest {
	public static class Thread1 extends Thread{
		private String name;
		public Thread1(String name){
			super(name);
			this.name = name;
		}
		public void run(){
			System.out.println(Thread.currentThread().getName() + "线程开始！");
			for(int i = 0; i < 5; i++){
				System.out.println("子线程" + name + "运行：" + i);
				try {
					sleep((int) (Math.random() * 10));
				} catch (InterruptedException e) {
					e.printStackTrace();					
				}
			}
			System.out.println(Thread.currentThread().getName() + "线程结束！");
		}
	}
	public static void main(String[] args) {
		System.out.println(Thread.currentThread().getName() + "主线程开始！");
		Thread1 th1 = new Thread1("甲");
		Thread1 th2 = new Thread1("乙");
		th1.start();
		th2.start();
		System.out.println(Thread.currentThread().getName() + "主线程结束！ ");
	}
}

运行结果：

main主线程开始！
甲线程开始！
main主线程结束！ 
乙线程开始！
子线程乙运行：0
子线程甲运行：0
子线程乙运行：1
子线程甲运行：1
子线程甲运行：2
子线程甲运行：3
子线程甲运行：4
子线程乙运行：2
甲线程结束！
子线程乙运行：3
子线程乙运行：4
乙线程结束！

由此可以看出，主线程在子线程结束前已经结束。

加入join()方法之后：

public static void main(String[] args) {
		System.out.println(Thread.currentThread().getName() + "主线程开始！");
		Thread1 th1 = new Thread1("甲");
		Thread1 th2 = new Thread1("乙");
		th1.start();
		th2.start();
		try {
			th1.join();
			th2.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName() + "主线程结束！ ");
	}

运行结果：

main主线程开始！
乙线程开始！
甲线程开始！
子线程乙运行：0
子线程甲运行：0
子线程甲运行：1
子线程乙运行：1
子线程甲运行：2
子线程甲运行：3
子线程甲运行：4
子线程乙运行：2
甲线程结束！
子线程乙运行：3
子线程乙运行：4
乙线程结束！
main主线程结束！

加入join()方法之后，主线程一定会等子线程结束之后再结束。

③yield():暂停当前正在执行的线程对象，并执行其他线程。

Thread.yield()方法的作用是：暂停当前正在执行的线程对象，并执行其他线程。

yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

结论：yield()从运行状态线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。可看上面的图。

public class YieldTest {
	public static class Thread1 extends Thread{
		public Thread1(String name){
			super(name);
		}
		public void run(){
			for(int i=1;i<10;i++){
				System.out.println(this.getName() +"........."+ i);
				if(i==5){
					System.out.println("开始切换线程");
					Thread1.yield();
				}
			}
		}
	}
	public static void main(String[] args) {
		Thread1 th1 = new Thread1("张三");
		Thread1 th2 = new Thread1("李四");
		th1.start();
		th2.start();
	}
}

运行结果：

第一种情况：李四（线程）当执行到30时会CPU时间让掉，这时张三（线程）抢到CPU时间并执行。

第二种情况：李四（线程）当执行到30时会CPU时间让掉，这时李四（线程）抢到CPU时间并执行。

sleep()和yield()的区别
        sleep()和yield()的区别):sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会被执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
        sleep 方法使当前运行中的线程睡眼一段时间，进入不可运行状态，这段时间的长短是由程序设定的，yield 方法使当前线程让出 CPU 占有权，但让出的时间是不可设定的。实际上，yield()方法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把 CPU  的占有权交给此线程，否则，继续运行原来的线程。所以yield()方法称为“退让”，它把运行机会让给了同等优先级的其他线程
       另外，sleep 方法允许较低优先级的线程获得运行机会，但 yield()  方法执行时，当前线程仍处在可运行状态，所以，不可能让出较低优先级的线程些时获得 CPU 占有权。在一个运行系统中，如果较高优先级的线程没有调用 sleep 方法，又没有受到 I\O 阻塞，那么，较低优先级线程只能等待所有较高优先级的线程运行结束，才有机会运行。
④setPriority(): 更改线程的优先级。

　　　　MIN_PRIORITY = 1
　　 NORM_PRIORITY = 5
MAX_PRIORITY = 10

用法：

public static void main(String[] args) {
		Thread1 th1 = new Thread1("张三");
		Thread1 th2 = new Thread1("李四");
		th1.setPriority(7);
		th2.setPriority(6);
		th1.start();
		th2.start();
	}

运行结果：
⑤interrupt():不要以为它是中断某个线程！它只是线线程发送一个中断信号，让线程在无限等待时（如死锁时）能抛出抛出，从而结束线程，但是如果你吃掉了这个异常，那么这个线程还是不会中断的！

⑥wait()

Obj.wait()，与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait,与notify是针对已经获取了Obj锁进行操作，从语法角度来说就是Obj.wait(),Obj.notify必须在synchronized(Obj){...}语句块内。从功能上来说wait就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。相应的notify()就是对对象锁的唤醒操作。但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作。Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于Object.wait()在释放CPU同时，释放了对象锁的控制。

单单在概念上理解清楚了还不够，需要在实际的例子中进行测试才能更好的理解。对Object.wait()，Object.notify()的应用最经典的例子，应该是三线程打印ABC的问题了吧，这是一道比较经典的面试题，题目要求如下：

建立三个线程，A线程打印10次A，B线程打印10次B,C线程打印10次C，要求线程同时运行，交替打印10次ABC。这个问题用Object的wait()，notify()就可以很方便的解决。代码如下：

public class NotifyTest {
	public static class Thread1 implements Runnable{
		private String name;     
	    private Object prev;     
	    private Object self;
	    private Thread1(String name,Object prev,Object self){
	    	this.name = name;     
	        this.prev = prev;     
	        this.self = self;
	    }
		@Override
		public void run() {
			int count = 10;
			while(count > 0){
				synchronized (prev) {
					synchronized (self) {
						System.out.println(name);
						count--;
						self.notify();
					}
					try {
						prev.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
			
		}		
	}
	public static void main(String[] args) throws InterruptedException {
		Object a = new Object();     
        Object b = new Object();     
        Object c = new Object();
        Thread1 pa = new Thread1("A", c, a);
        Thread1 pb = new Thread1("B", a, b);
        Thread1 pc = new Thread1("C", b, c);
        new Thread(pa).start();
        Thread.sleep(100);
        new Thread(pb).start();
        Thread.sleep(100);
        new Thread(pc).start();
        Thread.sleep(100);
	}
}

运行结果：ABCABC ABCABC ABCABC ABCABC ABCABC

先来解释一下其整体思路，从大的方向上来讲，该问题为三线程间的同步唤醒操作，主要的目的就是ThreadA->ThreadB->ThreadC->ThreadA循环执行三个线程。为了控制线程执行的顺序，那么就必须要确定唤醒、等待的顺序，所以每一个线程必须同时持有两个对象锁，才能继续执行。一个对象锁是prev，就是前一个线程所持有的对象锁。还有一个就是自身对象锁。主要的思想就是，为了控制执行的顺序，必须要先持有prev锁，也就前一个线程要释放自身对象锁，再去申请自身对象锁，两者兼备时打印，之后首先调用self.notify()释放自身对象锁，唤醒下一个等待线程，再调用prev.wait()释放prev对象锁，终止当前线程，等待循环结束后再次被唤醒。运行上述代码，可以发现三个线程循环打印ABC，共10次。程序运行的主要过程就是A线程最先运行，持有C,A对象锁，后释放A,C锁，唤醒B。线程B等待A锁，再申请B锁，后打印B，再释放B，A锁，唤醒C，线程C等待B锁，再申请C锁，后打印C，再释放C,B锁，唤醒A。看起来似乎没什么问题，但如果你仔细想一下，就会发现有问题，就是初始条件，三个线程按照A,B,C的顺序来启动，按照前面的思考，A唤醒B，B唤醒C，C再唤醒A。但是这种假设依赖于JVM中线程调度、执行的顺序。

wait和sleep区别
sleep就是正在执行的线程主动让出cpu，cpu去执行其他线程，在sleep指定的时间过后，cpu才会回到这个线程上继续往下执行，如果当前线程进入了同步锁，sleep方法并不会释放锁，即使当前线程使用sleep方法让出了cpu，但其他被同步锁挡住了的线程也无法得到执行。wait是指在一个已经进入了同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行，只有其他线程调用了notify方法（notify并不释放锁，只是告诉调用过wait方法的线程可以去参与获得锁的竞争了，但不是马上得到锁，因为锁还在别人手里，别人还没释放。如果notify方法后面的代码还有很多，需要这些代码执行完后才会释放锁，可以在notfiy方法后增加一个等待和一些代码，看看效果），调用wait方法的线程就会解除wait状态和程序可以再次得到锁后继续向下运行
所以sleep()和wait()方法的最大区别是：
　　　　sleep()睡眠时，保持对象锁，仍然占有该锁；
　　　　而wait()睡眠时，释放对象锁。
　　但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException（但不建议使用该方法）。
补充：

sleep()方法为什么不会释放锁？

sleep()是Thread类的静态方法，因此它不能改变对象的机锁，所以在synchronized块中调用sleep()方法时，线程虽然休眠了，但是对象的机锁并没有释放，其他线程无法访问这个对象，在sleep()休眠期满之后，该线程不一定立马执行，这是因为其他线程正在运行而且没有被调度为放弃运行，除非此线程具有更高的优先级

wait()方法为什么会释放锁？

wait()是Object类的方法，它进入到一个和该对象相关的等待池中，同时失去（释放）了对象的机锁，超时时间到后还需要返还对象锁，其他线程可以访问。

wait()使用notify()或者notifyAll()或者指定睡眠时间来唤醒当前等待池中的线程。

wait()必须放在synchronized black中，否则会在program runtime时扔出“java.lang.IllegalMonitorStateException”异常

参考资料：http://blog.csdn.net/evankaka

罗卜丝粉

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java中多线程详解（二）

四、线程状态转换1、新建状态：new Thread();新创建了一个线程对象2、就绪状态：Runnable,线程对象创建后，其他线程调用了该对象的start()方法，该状态线程位于可运行线程池中，可运行，等待获取CPU的使用权3、运行状态：running，就绪状态的线程获取了CPU，执行程序代码4、阻塞状态：blocked，阻塞状态是因为线程由于某种原因放弃CPU使用权，暂
复制链接

扫一扫

专栏目录