【Java多线程与并发库】4.传统线程同步通信技术
我们先通过一道面试题来了解传统的线程同步通信。
题目:
子线程循环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.传统线程同步通信技术的更多相关文章
- Java并发基础05. 传统线程同步通信技术
先看一个问题: 有两个线程,子线程先执行10次,然后主线程执行5次,然后再切换到子线程执行10,再主线程执行5次--如此往返执行50次. 看完这个问题,很明显要用到线程间的通信了, 先分析一下思路:首 ...
- Java多线程与并发库高级应用-线程池
线程池 线程池的思想 线程池的概念与Executors类的应用 > 创建固定大小的线程池 > 创建缓存线程池 > 创建单一线程池(如何实现线程死掉后重新启动?) 关闭线程池 > ...
- Java多线程与并发库高级应用-传统线程机制回顾
1.传统线程机制的回顾 1.1创建线程的两种传统方式 在Thread子类覆盖的run方法中编写运行代码 // 1.使用子类,把代码放到子类的run()中运行 Thread thread = new T ...
- Java多线程与并发库高级应用-传统线程同步通信技术
面试题: 子线程循环10次,接着主线程循环100次,接着又回到子线程循环10次,接着又 主线程循环100次,如此循环50次,请写出程序 /** * 子线程循环10次,接着主线程循环100次,接着又回到 ...
- Java多线程与并发库高级应用-java5线程并发库
java5 中的线程并发库 主要在java.util.concurrent包中 还有 java.util.concurrent.atomic子包和java.util.concurrent.lock子包 ...
- Java多线程与并发库高级应用-工具类介绍
java.util.concurrent.Lock 1.Lock比传统线程模型中的synchronized方式更加面向对象,与生活中的锁类似,锁本身也应该是一个对象.两个线程执行的代码片段要实现同步互 ...
- Java多线程与并发库高级应用-Callable与Future的应用
Callable这种任务可以返回结果,返回的结果可以由Future去拿 >Future取得的结果类型和Callable返回的结果类型必须一致,这是通过泛型来实现的. >Completion ...
- Java多线程与并发库高级应用-传统线程互斥技术
线程安全问题: 多个线程操作同一份数据的时候,有可能会出现线程安全问题.可以用银行转账来解释. 模拟线程安全问题 /** * 启动两个线程分别打印两个名字,名字按照字符一个一个打印 * * @aut ...
- Java多线程与并发库高级应用-传统定时器技术回顾
传统定时器技术回顾(jdk1.5以前) public class TraditionalTimerTest { static int count = 0; public static void mai ...
随机推荐
- 【转】Flask安装
Flask 依赖两个外部库:Werkzeug 和 Jinja2 . Werkzeug 是一个 WSGI(在 Web 应用和多种服务器之间的标准 Python 接口) 工具集.Jinja2 负责渲染模板 ...
- AVL树的左旋右旋理解 (转)
AVL树是最先发明的自平衡二叉查找树.在AVL树中任何节点的两个子树的高度最大差别为一,所以它也被称为高度平衡树.查找.插入和删除在平均和最坏情况下都是O(log n).增加和删除可能需要通过一次或多 ...
- 使用wampserver安装Composer的注意事项
http://getcomposer.org/Composer-Setup.exe 修改C:\wamp\bin\php\php5.3.10中php.ini中的配置 在php.ini中开启php_ope ...
- CSS 最核心的几个概念
CSS 中最核心的几个概念,包括:盒模型.position.float等. 这些是 CSS 的基础,也是最常用的几个属性,它们之间看似独立却又相辅相成. 元素类型 HTML 的元素可以分为两种: 块级 ...
- 批处理(.bat)中使用相对路径
批处理中使用相对路径,只需要用cd /d %~dp0代替绝对路径就可以了. ->cd /d ->%~dp0 %0为当前批处理文件 %~d0 是指批处理所在的盘符 %~dp0 是指批处理所在 ...
- STL源码剖析之list的sort函数实现
SGI STL的list的函数的实现源码大致如下: //list 不能使用sort函数,因为list的迭代器是bidirectional_iterator, 而sort //sort函数要求rand ...
- 即时通讯(IM)
即时通讯(IM)功能是APP的重要功能之一,而开发好移动IM却绝非易事.通常来说,IM技术选型至少要解决以下问题:1. 协议选型 2. IM服务器选型 3. 对协议和服务器做相应修改,通常来说直接拿个 ...
- tuple类型的单词查询例子
17.3 重写前面的TextQuery程序,使用tuple代替QueryResult类. TextQuery.h #ifndef TEXTQUERY_H #define TEXTQUERY_H #in ...
- Performance Tuning of Spring/Hibernate Applications---reference
http://java.dzone.com/articles/performance-tuning For most typical Spring/Hibernate enterprise appli ...
- 【Debian百科】巨页
巨页 为什么使用巨页? 当一个进程使用一些内存的时候,CPU就把那部分内存标记成已被该进程使用的.为了提高效率,CPU会按4K字节块(它在很多平台上是默认值)分配内存.这些块被称作页.这些页可以被交换 ...