Java并发(二):线程协作 生产者/消费者、线程中断、线程让步、线程睡眠、线程合并
2017-03-28 11:07
453 查看
线程协作-生产者/消费者
上一篇讲述了线程的互斥(同步),但是在很多情况下,仅仅同步是不够的,还需要线程与线程协作(通信),生产者/消费者问题是一个经典的线程同步以及通信的案例。该问题描述了两个共享固定大小缓冲区的线程,即所谓的“生产者”和“消费者”在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中,然后重复此过程。与此同时,消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据,消费者也不会在缓冲区中空时消耗数据。要解决该问题,就必须让生产者在缓冲区满时休眠(要么干脆就放弃数据),等到下次消费者消耗缓冲区中的数据的时候,生产者才能被唤醒,开始往缓冲区添加数据。同样,也可以让消费者在缓冲区空时进入休眠,等到生产者往缓冲区添加数据之后,再唤醒消费者,通常采用线程间通信的方法解决该问题。如果解决方法不够完善,则容易出现死锁的情况。出现死锁时,两个线程都会陷入休眠,等待对方唤醒自己。该问题也能被推广到多个生产者和消费者的情形。本文讲述了JDK5之前传统线程的通信方式,更高级的通信方式可参见后续文章。假设有这样一种情况,有一个盘子,盘子里只能放一个鸡蛋,A线程专门往盘子里放鸡蛋,如果盘子里有鸡蛋,则一直等到盘子里没鸡蛋,B线程专门从盘子里取鸡蛋,如果盘子里没鸡蛋,则一直等到盘子里有鸡蛋。这里盘子是一个互斥区,每次放鸡蛋是互斥的,每次取鸡蛋也是互斥的,A线程放鸡蛋,如果这时B线程要取鸡蛋,由于A没有释放锁,B线程处于等待状态,进入阻塞队列,放鸡蛋之后,要通知B线程取鸡蛋,B线程进入就绪队列,反过来,B线程取鸡蛋,如果A线程要放鸡蛋,由于B线程没有释放锁,A线程处于等待状态,进入阻塞队列,取鸡蛋之后,要通知A线程放鸡蛋,A线程进入就绪队列。我们希望当盘子里有鸡蛋时,A线程阻塞,B线程就绪,盘子里没鸡蛋时,A线程就绪,B线程阻塞,代码如下:
import java.util.ArrayList; import java.util.List; /** 定义一个盘子类,可以放鸡蛋和取鸡蛋 */ public class Plate { /** 装鸡蛋的盘子 */ List<Object> eggs = new ArrayList<Object>(); /** 取鸡蛋 */ public synchronized Object getEgg() { while (eggs.size() == 0) { try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } Object egg = eggs.get(0); eggs.clear();// 清空盘子 notify();// 唤醒阻塞队列的某线程到就绪队列 System.out.println("拿到鸡蛋"); return egg; } /** 放鸡蛋 */ public synchronized void putEgg(Object egg) { while (eggs.size() > 0) { try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } eggs.add(egg);// 往盘子里放鸡蛋 notify();// 唤醒阻塞队列的某线程到就绪队列 System.out.println("放入鸡蛋"); } static class AddThread implements Runnable { private Plate plate; private Object egg = new Object(); public AddThread(Plate plate) { this.plate = plate; } public void run() { plate.putEgg(egg); } } static class GetThread implements Runnable { private Plate plate; public GetThread(Plate plate) { this.plate = plate; } public void run() { plate.getEgg(); } } public static void main(String args[]) { Plate plate = new Plate(); for(int i = 0; i < 10; i++) { new Thread(new AddThread(plate)).start(); new Thread(new GetThread(plate)).start(); } } }
输出结果:
放入鸡蛋 拿到鸡蛋 放入鸡蛋 拿到鸡蛋 放入鸡蛋 拿到鸡蛋 放入鸡蛋 拿到鸡蛋 放入鸡蛋 拿到鸡蛋 放入鸡蛋 拿到鸡蛋 放入鸡蛋 拿到鸡蛋 放入鸡蛋 拿到鸡蛋 放入鸡蛋 拿到鸡蛋 放入鸡蛋 拿到鸡蛋
程序开始,A线程判断盘子是否为空,放入一个鸡蛋,并且唤醒在阻塞队列的一个线程,阻塞队列为空;假设CPU又调度了一个A线程,盘子非空,执行等待,这个A线程进入阻塞队列;然后一个B线程执行,盘子非空,取走鸡蛋,并唤醒阻塞队列的A线程,A线程进入就绪队列,此时就绪队列就一个A线程,马上执行,放入鸡蛋;如果再来A线程重复第一步,在来B线程重复第二步,整个过程就是生产者(A线程)生产鸡蛋,消费者(B线程)消费鸡蛋。
前段时间看了张孝祥老师线程的视频,讲述了一个其学员的面试题,也是线程通信的,在此也分享一下。
题目:子线程循环10次,主线程循环100次,如此循环100次,好像是空中网的笔试题。
public class ThreadTest2 { public static void main(String[] args) { final Business business = new Business(); new Thread(new Runnable() { @Override public void run() { threadExecute(business, "sub"); } }).start(); threadExecute(business, "main"); } public static void threadExecute(Business business, String threadType) { for(int i = 0; i < 100; i++) { try { if("main".equals(threadType)) { business.main(i); } else { business.sub(i); } } catch (InterruptedException e) { e.printStackTrace(); } } } } class Business { private boolean bool = true; public synchronized void main(int loop) throws InterruptedException { while(bool) { this.wait(); } for(int i = 0; i < 100; i++) { System.out.println("main thread seq of " + i + ", loop of " + loop); } bool = true; this.notify(); } public synchronized void sub(int loop) throws InterruptedException { while(!bool) { this.wait(); } for(int i = 0; i < 10; i++) { System.out.println("sub thread seq of " + i + ", loop of " + loop); } bool = false; this.notify(); } }
大家注意到没有,在调用wait方法时,都是用while判断条件的,而不是if,在wait方法说明中,也推荐使用while,因为在某些特定的情况下,线程有可能被假唤醒,使用while会循环检测更稳妥。wait和notify方法必须工作于synchronized内部,且这两个方法只能由锁对象来调用。
线程中断、让步、睡眠、合并
理解了线程同步和线程通信之后,再来看本文的知识点就会简单的多了,本文是做为传统线程知识点的一个补充。有人会问:JDK5之后有了更完善的处理多线程问题的类(并发包),我们还需要去了解传统线程吗?答:需要。在实际开发中,无外乎两种情况,一个是开发新内容,另一个是维护原有程序。开发新内容可以使用新的技术手段,但是我们不能保证原有程序是用什么实现的,所以我们需要了解原有的。另外一点,了解传统线程的工作原理,使我们在使用并发包时更加得心应手。线程中断:
线程中断涉及到三个方法,如下:返回值 | 方法名 | 备注 |
---|---|---|
void | interrupt() | 中断线程。 |
static boolean | interrupted() | 测试当前线程是否已经中断。 |
boolean | isInterrupted() | 测试线程是否已经中断。 |
public class InterruptTest { public static void main(String[] args) throws InterruptedException { MyThread t = new MyThread("MyThread"); t.start(); Thread.sleep(100);// 睡眠100毫秒 t.interrupt();// 中断t线程 } } class MyThread extends Thread { int i = 0; public MyThread(String name) { super(name); } public void run() { while(true) {// 死循环,等待被中断 System.out.println(getName() + getId() + "执行了" + ++i + "次"); } } }
运行后,我们发现,线程t一直在执行,没有被中断,原来interrupt()是骗人的,汗!其实interrupt()方法并不是中断线程的执行,而是为调用该方法的线程对象打上一个标记,设置其中断状态为true,通过isInterrupted()方法可以得到这个线程状态,我们将上面的程序做一个小改动:
public class InterruptTest { public static void main(String[] args) throws InterruptedException { MyThread t = new MyThread("MyThread"); t.start(); Thread.sleep(100);// 睡眠100毫秒 t.interrupt();// 中断t线程 } } class MyThread extends Thread { int i = 0; public MyThread(String name) { super(name); } public void run() { while(!isInterrupted()) {// 当前线程没有被中断,则执行 System.out.println(getName() + getId() + "执行了" + ++i + "次"); } } }
这样的话,线程被顺利的中断执行了。很多人实现一个线程类时,都会再加一个flag标记,以便控制线程停止执行,其实完全没必要,通过线程自身的中断状态,就可以完美实现该功能。如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法,或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻,则其中断状态将被清除,它还将收到一个 InterruptedException。 我们可以捕获该异常,并且做一些处理。另外,Thread.interrupted()方法是一个静态方法,它是判断当前线程的中断状态,需要注意的是,线程的中断状态会由该方法清除。换句话说,如果连续两次调用该方法,则第二次调用将返回 false(在第一次调用已清除了其中断状态之后,且第二次调用检验完中断状态前,当前线程再次中断的情况除外)。
线程让步
线程让步,其方法如下:返回值 | 方法名 | 备注 |
---|---|---|
static void | yield() | 暂停当前正在执行的线程对象,并执行其他线程 |
public class YieldTest { public static void main(String[] args) throws InterruptedException { // 创建线程对象 YieldThread t1 = new YieldThread("t1"); YieldThread t2 = new YieldThread("t2"); // 启动线程 t1.start(); t2.start(); // 主线程休眠100毫秒 Thread.sleep(100); // 终止线程 t1.interrupt(); t2.interrupt(); } } class YieldThread extends Thread { int i = 0; public YieldThread(String name) { super(name); } public void run() { while(!isInterrupted()) { System.out.println(getName() + "执行了" + ++i + "次"); if(i % 10 == 0) {// 当i能对10整除时,则让步 Thread.yield(); } } } }
输出结果略,从输出结果可以看到,当某个线程(t1或者t2)执行到10次、20次、30次等时,就会马上切换到另一个线程执行,接下来再交替执行,如此往复。注意,如果存在synchronized线程同步的话,线程让步不会释放锁(监视器对象)。
线程睡眠
线程睡眠涉及到两个方法,如下:返回值 | 方法名 | 备注 |
---|---|---|
static void | sleep(long millis) | 在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)。 |
static void | sleep(long millis, int nanos) | 在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠(暂停执行)。 |
public class SleepTest { public static void main(String[] args) { // 创建共享对象 Service service = new Service(); // 创建线程 SleepThread t1 = new SleepThread("t1", service); SleepThread t2 = new SleepThread("t2", service); // 启动线程 t1.start(); t2.start(); } } class SleepThread extends Thread { private Service service; public SleepThread(String name, Service service) { super(name); this.service = service; } public void run() { service.calc(); } } class Service { public synchronized void calc() { System.out.println(Thread.currentThread().getName() + "准备计算"); System.out.println(Thread.currentThread().getName() + "感觉累了,开始睡觉"); try { Thread.sleep(10000);// 睡10秒 } catch (InterruptedException e) { return; } System.out.println(Thread.currentThread().getName() + "睡醒了,开始计算"); System.out.println(Thread.currentThread().getName() + "计算完成"); } }
输出结果:
t1准备计算 t1感觉累了,开始睡觉 t1睡醒了,开始计算 t1计算完成 t2准备计算 t2感觉累了,开始睡觉 t2睡醒了,开始计算 t2计算完成
线程合并
线程合并涉及到三个方法,如下:返回值 | 方法名 | 备注 |
---|---|---|
void | join() | 等待该线程终止。 |
void | join(long millis) | 等待该线程终止的时间最长为 millis 毫秒。 |
void | join(long millis, int nanos) | 等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。 |
public class JoinTest { public static void main(String[] args) throws InterruptedException { JoinThread t1 = new JoinThread("t1"); JoinThread t2 = new JoinThread("t2"); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println("主线程开始执行!"); } } class JoinThread extends Thread { public JoinThread(String name) { super(name); } public void run() { for(int i = 1; i <= 10; i++) System.out.println(getName() + getId() + "执行了" + i + "次"); } }
t1和t2都执行完才继续主线程的执行,所谓合并,就是等待其它线程执行完,再执行当前线程,执行起来的效果就好像把其它线程合并到当前线程执行一样。
线程优先级
线程最低优先级为1,最高优先级为10,看起来就有10个级别,但这10个级别能不能和CPU对应上,还未可知,Thread类中提供了优先级的三个常量,如下://所属类: java.lang.Thread
修饰域的关键字 | 常量名 | 表示值 |
---|---|---|
public static final int | MAX_PRIORITY | 10 |
public static final int | MIN_PRIORITY | 1 |
public static final int | NORM_PRIORITY | 5 |
wait()和sleep()区别
区别太大了,但是在Java线程面试题中是很常见的问题,相信你阅读过本专栏后,能够轻松的解答,这里不再赘述。本文来自:高爽|Coder,原文地址:http://blog.csdn.net/ghsau/article/details/17560467,转载请注明。
相关文章推荐
- Java线程:并发协作-生产者消费者模型 转自:http://lavasoft.blog.51cto.com/62575/221932
- Java线程:并发协作-生产者消费者模型
- Java线程(四):线程中断、线程让步、线程睡眠、线程合并
- Java线程:并发协作-生产者消费者模型
- Java线程(四):线程中断、线程让步、线程睡眠、线程合并
- Java线程:并发协作-生产者消费者模型 转自:http://lavasoft.blog.51cto.com/62575/221932
- Java线程:并发协作-生产者消费者模型
- Java线程:并发协作-生产者消费者模型
- Java线程:并发协作-生产者消费者模型
- Java线程(四):线程中断、线程让步、线程睡眠、线程合并
- Java线程:并发协作-生产者消费者模型
- Java线程:并发协作-生产者消费者模型
- Java线程:并发协作-生产者消费者模型
- Java线程:并发协作-生产者消费者模型
- Java线程:并发协作-生产者消费者模型
- Java线程(四):线程中断、线程让步、线程睡眠、线程合并
- Java线程:并发协作-生产者消费者模型
- Java线程(四):线程中断、线程让步、线程睡眠、线程合并
- Java线程:并发协作-生产者消费者模型
- Java线程:并发协作-生产者消费者模型