我们先通过一道面试题来了解传统的线程同步通信。

题目:
子线程循环10次,接着主线程循环100次,接着又回到子线程循环10次,
接着再回到主线程又循环100次,如此循环50次,请写出程序。

我没有看答案,先用自己的思路写了一段代码,有一些是借鉴传统的“生产者与消费者”的
多线程模型写出来的:
[java] view plain copy 在CODE上查看代码片派生到我的代码片
package cn.edu.hpu.test;

/**
* 要求的操作:
* 子线程循环10次,接着主线程循环100次,接着又回到子线程循环10次,
* 接着再回到主线程又循环100次,如此循环50次。
* **/
public class ThreadTest3 {

public static void main(String[] args) {
Output out =new Output();//循环输出类
//注意:这里要保证子线程和主线程类引入的是同一个Output对象
//不然无法共用两把“钥匙”
MainRunnable main=new MainRunnable(out);//主线程
SonRunnable son=new SonRunnable(out);//子线程
new Thread(son).start();//主线程启动
new Thread(main).start();//子线程启动
}
}

class Output{

//两把“钥匙”
static boolean mbegin=false;
static boolean sbegin=true;//第一次子线程开始执行,所以这里默认为true

//主线程循环打印的方法(不可被打断)
public synchronized void doMainWhile(int num) throws InterruptedException {
int i=0;//每次i都要初始化为0,供循环使用
while(mbegin==false){//如果子线程在执行,主线程要等待,直到子线程恢复主线程的钥匙
this.wait();
}
for (i = 1; i <=100; i++) {//开始循环(每次在方法里循环100次)
System.out.println("主线程执行了第"+i+"次循环,总循环为第"+num+"次");
if(i==100){
break;
}
}
if(i==100){//主线程循环打印完毕之后,要让位给子线程执行
sbegin=true;//子线程开始工作
mbegin=false;//主线程停止工作
this.notify();//通知其他线程开始工作
}
}

//子线程循环打印的方法(不可被打断)
public synchronized void doSonWhile(int num) throws InterruptedException {
int j=0;//每次i都要初始化为0,供循环使用
while(sbegin==false){//如果主线程在执行,子线程要等待,直到主线程恢复子线程的钥匙
this.wait();
}
for (j = 1; j <=10; j++) {//开始循环(每次在方法里循环10次)
System.out.println("子线程执行了第"+j+"次循环,总循环为第"+num+"次");
if(j==10){
break;
}
}
if(j==10){//子线程循环打印完毕之后,要让位给主线程执行
sbegin=false;//子线程停止工作
mbegin=true;//主线程开始
this.notify();//通知其他线程开始工作
}
}

}

class MainRunnable implements Runnable{

Output out =null;

MainRunnable(Output out){//将Output对象引入进来
this.out=out;
}

public void run() {
try {
//因为要执行50次要求的操作,每次操作主线程要执行2次,一共50*2=100次
for(int i=1;i<=100;i++){
out.doMainWhile(i%2==0?i/2:(i+1)/2);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}

class SonRunnable implements Runnable{

Output out =null;

SonRunnable(Output out){
this.out=out;
}

public void run() {
try {
//因为要执行50次要求的操作,每次操作子线程要执行2次,一共50*2=100次
for(int i=1;i<=100;i++){
out.doSonWhile(i%2==0?i/2:(i+1)/2);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}

首先我是创建了一个循环类,然后使用这个循环类进行循环打印操作,而且针对子线程和主线程使用不同的方法去执行,
其中主线程的循环打印方法中,让其打印100次,然后子线程的循环打印方法中,让其打印50次,而且使用关键字synchronized
保证各自的方法不会被打断。
给主线程和子线程传入共同的Output对象,可以保证共用统一的静态全部变量(就是里面的两把“钥匙”)。

线程的执行规则就是,一开始先让子线程运行(主线程其实也运行了,只是mbegin变量为false让其阻塞了),运行完其循环10次的
方法之后,改变sbegin和mbegin的值,并通知其它线程。此时子线程由于sbegin变量为false而阻塞,主线程由于mbegin变量为true
而开始运行,主线程执行完自己的100次循环之后,改变sbegin和mbegin的值,并通知其它线程。此时主线程由于mbegin变量为false
而阻塞,而子线程由于sbegin变量为true而开始运行...如此这般就完成了一轮循环。
保证种循环执行50次的控制,就在于每个线程自己的for循环,他们其实每次大循环中,各自执行了两遍自己的循环打印方法,所以
他们每个线程执行50*2=100次循环打印方法就可以了。

结果(图片太长只截取了一次循环的某三步):

后来,我用参数计数得出一共循环了50次的大循环,结果是正确的。

但是我个人认为我只是单纯的实现了这种效果,代码拓展新不好,写法有点屌丝,
控制线程运行和阻塞的方法也不是太好(用了两个全局变量mbegin和sbegin)=_=。

下面看一下人家提供的一种答案吧:
[java] view plain copy 在CODE上查看代码片派生到我的代码片
package cn.edu.hpu.test;

public class ThreadTest4 {

public static void main(String[] args) {
new ThreadTest4().init();
}

public void init()
{
final Business business = new Business();
new Thread(
new Runnable()
{

public void run() {
for(int i=0;i<50;i++)
{
business.SubThread(i);
}
}

}

).start();

for(int i=0;i<50;i++)
{
business.MainThread(i);
}
}

private class Business
{
boolean bShouldSub = true;//这里相当于定义了控制该谁执行的一个信号灯
public synchronized void MainThread(int i)
{
if(bShouldSub)
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}

for(int j=1;j<=100;j++)
{
System.out.println(Thread.currentThread().getName() + ":i=" + i +",j=" + j);
}
bShouldSub = true;
this.notify();

}

public synchronized void SubThread(int i)
{
if(!bShouldSub)
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}

for(int j=1;j<=10;j++)
{
System.out.println(Thread.currentThread().getName() + ":i=" + i +",j=" + j);
}
bShouldSub = false;
this.notify();
}
}
}

结果(也是图片太长只截取了一次循环的某三步):

实际上答案给出的方法和我自己写的差不多,也是创建一个共用的类去循环打印数据,并分别给
子线程和主线程提供一个循环打印的方法,和我不同的是,他们使用的是同一个共用变量去控制
线程的启动和阻塞,而我使用了两个,而且答案的代码格式和命名都比较规范,这一点要改进。

另外,除了使用以上方法外,还提供了一个使用JDK5的“并法库”的方法来解决此问题:
[java] view plain copy 在CODE上查看代码片派生到我的代码片
package cn.edu.hpu.test;

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Condition;

public class ThreadTest5 www.zhenlyule.cn
{
private static Lock lock = new ReentrantLock();
private static Condition subThreadCondition = lock.newCondition();
private static boolean bBhouldSubThread = www.yyzx66.cn/ false;
public static void main(String [] args)
{
ExecutorService threadPool = Executors.newFixedThreadPool(3);
threadPool.execute(new Runnable(){
public void www.egouyuLe.cn run()
{
for(int i=0;i<50;i++)
{
lock.lock();
try
{
if(!bBhouldSubThread)
subThreadCondition.await();
forwww.yinb666.cn (int j=0;j<10;j++)
{
System.out.println(Thread.currentThread().getName() + ",j=" + j);
}
bBhouldSubThread = false;
subThreadCondition.signal();
}catch(Exception e)
{
}
finally
{
lock.unlock();
}
}
}

});
threadPool.shutdown();
for(int i=0;i<50;i++)
{
lock.lock();
try
{
if(bBhouldSubThread)
subThreadCondition.await();
for(int j=0;j<10;j++)
{
System.out.www.huarenc88.cn/ println(Thread.currentThread().getName() + ",j=" + j);
}
bBhouldSubThread = true;
subThreadCondition.signal();
}catch(Exception e)
{
}
finally
{
lock.unlock();
}
}
}
}

至此,我们通过完成该面试题,可以充分理解什么是线程同步通信,其实就是
线程在同一时间运行,然后通过一些变量或手段去让线程之间进行相互交替的运行,
来达到我们使用多线程的目的。

【Java多线程与并发库】4.传统线程同步通信技术的更多相关文章

  1. Java并发基础05. 传统线程同步通信技术

    先看一个问题: 有两个线程,子线程先执行10次,然后主线程执行5次,然后再切换到子线程执行10,再主线程执行5次--如此往返执行50次. 看完这个问题,很明显要用到线程间的通信了, 先分析一下思路:首 ...

  2. Java多线程与并发库高级应用-线程池

    线程池 线程池的思想  线程池的概念与Executors类的应用 > 创建固定大小的线程池 > 创建缓存线程池 > 创建单一线程池(如何实现线程死掉后重新启动?) 关闭线程池 > ...

  3. Java多线程与并发库高级应用-传统线程机制回顾

    1.传统线程机制的回顾 1.1创建线程的两种传统方式 在Thread子类覆盖的run方法中编写运行代码 // 1.使用子类,把代码放到子类的run()中运行 Thread thread = new T ...

  4. Java多线程与并发库高级应用-传统线程同步通信技术

    面试题: 子线程循环10次,接着主线程循环100次,接着又回到子线程循环10次,接着又 主线程循环100次,如此循环50次,请写出程序 /** * 子线程循环10次,接着主线程循环100次,接着又回到 ...

  5. Java多线程与并发库高级应用-java5线程并发库

    java5 中的线程并发库 主要在java.util.concurrent包中 还有 java.util.concurrent.atomic子包和java.util.concurrent.lock子包 ...

  6. Java多线程与并发库高级应用-工具类介绍

    java.util.concurrent.Lock 1.Lock比传统线程模型中的synchronized方式更加面向对象,与生活中的锁类似,锁本身也应该是一个对象.两个线程执行的代码片段要实现同步互 ...

  7. Java多线程与并发库高级应用-Callable与Future的应用

    Callable这种任务可以返回结果,返回的结果可以由Future去拿 >Future取得的结果类型和Callable返回的结果类型必须一致,这是通过泛型来实现的. >Completion ...

  8. Java多线程与并发库高级应用-传统线程互斥技术

     线程安全问题: 多个线程操作同一份数据的时候,有可能会出现线程安全问题.可以用银行转账来解释. 模拟线程安全问题 /** * 启动两个线程分别打印两个名字,名字按照字符一个一个打印 * * @aut ...

  9. Java多线程与并发库高级应用-传统定时器技术回顾

    传统定时器技术回顾(jdk1.5以前) public class TraditionalTimerTest { static int count = 0; public static void mai ...

随机推荐

  1. rtsp的东西

    http://ubuntuforums.org/showthread.php?t=1544946 http://www.live555.com/liveCaster/liveInput.html ht ...

  2. Django中的ORM进阶操作

    Django中的ORM进阶操作 Django中是通过ORM来操作数据库的,通过ORM可以很easy的实现与数据库的交互.但是仍然有几种操作是非常绕也特别容易混淆的.于是,针对这一块,来一个分类总结吧. ...

  3. 黑马程序员_<<GUI(图形用户界面)--------1>>

    --------------------ASP.Net+Android+IOS开发..Net培训.期待与您交流! -------------------- 1.  GUI图形用户界面 1.简述 Gra ...

  4. Gamma校正及其OpenCV实现

    參考:[1]http://www.cambridgeincolour.com/tutorials/gamma-correction.htm [2]http://en.wikipedia.org/wik ...

  5. VSS的运用小内容(针对于vs2008版本)(小的问题都是,仅供参考--只针对于菜鸟级的)

    自己开始接触vss 的时候有些小的习惯没有很好的养成,下面的有关VSS内容都是简单的迁入迁出的问题,(仅供参考) 1.文件的迁入迁出:(.txt..xlsx..doc) a:文件的覆盖问题: 对于文件 ...

  6. Swift 实现图片转字符画的功能

    本文介绍一个IOS APP , 将图片转换成ASCII字符画,使用Swift语言编写. 举个例子,我们使用著名的蕾娜照片作为原图片 经APP转换后形成的字符画,我们打印出来,效果如下: 放大她的脸部可 ...

  7. java多线程之消费者生产者模式 (转)

    /*@author shijin * 生产者与消费者模型中,要保证以下几点: * 1 同一时间内只能有一个生产者生产 生产方法加锁sychronized * 2 同一时间内只能有一个消费者消费 消费方 ...

  8. iOS Runtime 实践(1)

    很多时候我们都在看iOS开发中的黑魔法——Runtime.懂很多,但如何实践却少有人提及.本文便是iOS Runtime的实践第一篇. WebView 我们这次的实践主题,是使用针对接口编程的方式,借 ...

  9. Java基础知识强化之集合框架笔记50:Map集合之Map集合的概述和特点

    1. Map集合的概述: public interface Map<K,V> 作为学生来说,是根据学号来区分不同的学生的,那么假设我现在已经知道了学生的学号,我要根据学号去获取学生姓名,请 ...

  10. Java基础知识强化之IO流笔记27:FileInputStream读取数据一次一个字节数组byte[ ]

    1. FileInputStream读取数据一次一个字节数组byte[ ]  使用FileInputStream一次读取一个字节数组: int read(byte[]  b) 返回值:返回值其实是实际 ...