文档章节

两个线程交替打印

秋风醉了
 秋风醉了
发布于 2016/09/12 17:39
字数 652
阅读 280
收藏 2

两个线程交替打印

交替打印一

主要是wait 和notify的应用,可以参见 http://my.oschina.net/xinxingegeya/blog/345816

利用wait 和notify实现两个线程交替打印0-100,代码如下,

/**
 * 两个线程交替打印数字
 * <p/>
 * 核心思想就是如何控制wait和notify
 */
public class Main {

    static final Object lock = new Object();
    static int num1 = 0;
    static int num2 = 1;
    static int end = 100;

    /**
     * volatile
     * 保证两个线程之间的内存可见性
     * <p/>
     * 0 for thread a to print
     * 1 for thread b to print
     */
    volatile static int state = 0;


    public static void main(String args[]) {
        // 两个线程 交替打印字符串
        Thread a = new Thread() {
            public void run() {
                /**
                 * 从语法角度来说就是Obj.wait(),Obj.notify必须在synchronized(Obj){...}语句块内
                 */
                while (true) {
                    synchronized (lock) {
                        if (state == 1) {
                            try {

                                /**
                                 * 当state=1时,需要释放对象锁,同时本线程休眠,
                                 * 直到有其它线程调用对象的notify()唤醒该线程,才能继续获取对象锁,并继续执行
                                 */
                                lock.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        state = 1;
                        if (num1 >= end) {
                            break;
                        }
                        System.out.println(num1);
                        num1 += 2;

                        /**
                         * notify()唤醒等待该对象锁的线程,但有一点需要注意的是notify()调用后,
                         * 并不是马上就释放对象锁的,而是在相应的synchronized(){}语句块执行结束,
                         * 自动释放锁后,JVM会在wait()对象锁的线程中随机选取一线程,赋予其对象锁,唤醒线程,继续执行.
                         * 这样就提供了在线程间同步、唤醒的操作.
                         */
                        lock.notify();
                    }
                }

            }
        };


        Thread b = new Thread() {
            public void run() {

                while (true) {
                    synchronized (lock) {

                        if (state == 0) {
                            try {
                                lock.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        state = 0;
                        if (num2 >= end) {
                            break;
                        }
                        System.out.println(num2);
                        num2 += 2;
                        lock.notify();
                    }
                }

            }
        };
        b.start();
        a.start();
    }

}

交替打印二

使用显示锁和条件对列实现线程的交替打印,

关于条件对列,http://my.oschina.net/xinxingegeya/blog/309323

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

/**
 * 使用条件队列实现线程的交替打印
 */
public class PrintMain {

    static final Lock lock = new ReentrantLock();
    static final Condition threadAPrint = lock.newCondition();
    static final Condition threadBPrint = lock.newCondition();

    static int num1 = 0;
    static int num2 = 1;
    static int end = 100;

    volatile static int state = 0;

    public static void main(String args[]) {

        final Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    /**
                     * 获取锁,获取锁不成功时,当前线程休眠,直到获取锁,继续执行
                     */
                    lock.lock();
                    try {
                        if (state == 1) {
                            try {

                                /**
                                 * Causes the current thread to wait until it is signalled or
                                 * {Thread#interrupt interrupted}.
                                 *
                                 * The lock associated with this {Condition} is atomically
                                 * released and the current thread becomes disabled for thread scheduling
                                 * purposes and lies dormant until <em>one</em> of four things happens...
                                 */
                                threadAPrint.await();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        state = 1;
                        if (num1 >= end) {
                            break;
                        }
                        System.out.println(num1);
                        num1 += 2;
                        /**
                         * Wakes up one waiting thread.
                         */
                        threadBPrint.signal();
                    } finally {
                        lock.unlock();
                    }
                }
            }
        });

        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {

                while (true) {
                    lock.lock();

                    try {
                        if (state == 0) {
                            try {
                                threadBPrint.await();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        state = 0;
                        if (num2 >= end) {
                            break;
                        }
                        System.out.println(num2);
                        num2 += 2;
                        threadAPrint.signal();
                    } finally {
                        lock.unlock();
                    }
                }

            }
        });

        threadA.start();
        threadB.start();
    }
}

======END======

© 著作权归作者所有

共有 人打赏支持
秋风醉了
粉丝 246
博文 543
码字总数 412294
作品 0
朝阳
程序员
私信 提问
一道有意思的多线程面试题 C# 代码实现

如果你对多线程的控制不怎么了解,那么理解了这篇文章的内容也许对你有帮助。鼓励先自己动手实现一遍,做不出来在看代码。 题目一:两个线程交替打印0~100的奇偶数 这道题就是说有两个线程,...

Ax0ne
03/21
0
0
多线程 wait(),notify()和notifyall()咨询

两个线程交替打印,两个线程都在做的就是 状态判断(暂且不提),还有就是进入冻结状态(wait() ),之后改状态,notify(),线程已经wait了,还可以调用notify?求解!!还有notify()可以唤醒线程...

msgyg
2017/09/09
59
2
GCD死锁,及同步、异步、串行和并行队列组合情形

一、概述 1)队列用来存储代码任务,线程用来运行代码任务; 2)main()函数作为程序入口,整个程序默认运行在主线程中,程序代码任务默认存放在主队列中; 3)以下所谓阻塞线程是针对主线程而...

春天里的花骨朵
02/14
0
0
Java多线程实现同步——wait()和notify()实现

要求:子线程循环5次,接着主线程循环10次,接着又回到子线程。如此循环50次。 实现以上要求的时候,除了直白的面向过程的实现,可以考虑面向对象的写法。 根据高内聚的原装,将子线程和主线...

文森特梵高
2015/08/20
0
0
java线程notify(), wait()的使用

回顾一个比较经典的线程间协作的问题:启动三个线程,每个线程相应的打印10遍A,10遍B,10遍C。要求三个线程交替执行,输处10遍ABC。 用Object类的notify(), wait()方法可实现上述要求。 Ob...

Rocky_chi
2016/02/22
76
0

没有更多内容

加载失败,请刷新页面

加载更多

分布式项目(五)iot-pgsql

书接上回,在Mapping server中,我们已经把数据都整理好了,现在利用postgresql存储历史数据。 iot-pgsql 构建iot-pgsql模块,这里我们写数据库为了性能考虑不在使用mybatis,换成spring jd...

lelinked
今天
2
0
一文分析java基础面试题中易出错考点

前言 这篇文章主要针对的是笔试题中出现的通过查看代码执行结果选择正确答案题材。 正式进入题目内容: 1、(单选题)下面代码的输出结果是什么? public class Base { private Strin...

一看就喷亏的小猿
今天
1
0
cocoapods 用法

cocoapods install pod install 更新本地已经install的仓库 更新所有的仓库 pod update --verbose --no-repo-update 更新制定的仓库 pod update ** --verbose --no-repo-update...

HOrange
今天
3
0
linux下socket编程实现一个服务器连接多个客户端

使用socekt通信一般步骤 1)服务器端:socker()建立套接字,绑定(bind)并监听(listen),用accept()等待客户端连接。 2)客户端:socker()建立套接字,连接(connect)服务器,连接上后...

shzwork
昨天
3
0
android自定义viewgroup画背景

设计部要求背景实现一个背景边框带圆弧的效果: 所以想着用自定义控件画一个背景。 为了方便,继承的是LinearLayout,在onMeasure中先获取控件宽高: @Overrideprotected void onMeasure(in...

醉雨
昨天
1
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部