java并发：多线程与volatile、AtomicInteger、ReentrantLock、Condition、Semaphore

最新推荐文章于 2021-10-17 11:01:11 发布

Mars-xq

最新推荐文章于 2021-10-17 11:01:11 发布

阅读量454

点赞数

分类专栏：并发线程

本文链接：https://blog.csdn.net/sinat_31057219/article/details/102825240

版权

线程同时被 2 个专栏收录

13 篇文章 0 订阅

订阅专栏

并发

9 篇文章 1 订阅

订阅专栏

参考：
Java 每日算法，三个线程按顺序打印

多个线程按顺序输出

题目一

启动3个线程A、B、C，
使A打印0，然后B打印1，然后C打印2，
A打印3，B打印4，C打印5，依次类推。

/**
 * 启动3个线程A、B、C，使A打印0，然后B打印1，然后C打印2，A打印3，B打印4，C打印5，依次类推。
 */
public class PrintSequenceThread implements Runnable {
    private static final Object LOCK = new Object();
    //当前即将打印的数字
    private static int currentValue = 0;
    //当前线程编号，从0开始
    private int threadNo;
    //线程数量
    private int threadCount;
    //打印的最大数值
    private int maxValue;

    public PrintSequenceThread(int threadNo, int threadCount, int maxValue) {
        this.threadNo = threadNo;
        this.threadCount = threadCount;
        this.maxValue = maxValue;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (LOCK) {
                // 判断是否轮到当前线程执行
                while (currentValue % threadCount != threadNo) {
                    if (currentValue > maxValue) {
                        break;
                    }
                    try {
                        // 如果不是，则当前线程进入wait
                        LOCK.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                // 最大值跳出循环
                if (currentValue > maxValue) {
                    break;
                }

                System.out.println("thread-" + threadNo + " : " + currentValue);
                currentValue++;
                // 唤醒其他wait线程
                LOCK.notifyAll();
            }
        }
    }

    public static void main(String[] args) {
        int threadCount = 3;
        int maxValue = 10;
        for (int threadNo = 0; threadNo < threadCount; threadNo++) {
            new Thread(new PrintSequenceThread(threadNo, threadCount, maxValue)).start();
        }
    }
}
//thread-0 : 0
//thread-1 : 1
//thread-2 : 2
//thread-0 : 3
//thread-1 : 4
//thread-2 : 5
//thread-0 : 6
//thread-1 : 7
//thread-2 : 8
//thread-0 : 9
//thread-1 : 10

题目二

编写一个程序，开启 3 个线程，
这三个线程的分别为 A、B、C，每个线程打印对应的“A”、“B”、“C” 100000 遍，
要求输出的结果必须按顺序显示。如：ABC ABC ABC……

前4种统一使用一个全局变量state进行条件控制：

（1）state初始化为1，
如果state为1执行A线程，A线程修改state为2执行B线程；
如果state为2执行B线程，B线程修改state为3企图执行C线程；
如果state为3执行C线程，C线程修改state为1，企图执行A线程。

（2）或者state初始化为0，
如果state取余3=0，执行A线程；
如果state取余3=1,执行B线程；
如果stat取余3=2，执行C线程。

示例索引：

解法1：采用volatile修饰的全局变量state作为条件控制，用for循环加if条件判断的忙等模式。

解法2:采用原子类AtomicInteger来控制变量state

解法3：采用ReentrantLock锁住整段代码

解法4：采用ReentrantLock，三个Condition进行await和signal操作

解法5：使用信号量机制，完全不用state变量进行条件控制

解法一


/**
 * 解法1：采用volatile修饰的全局变量state作为条件控制，用for循环加if条件判断的忙等模式。
 *
 * 问题：为什么共享变量要加volatile?加volatile就足够了吗？
 * 分析：因为加volatile可以保证变量state的可见性，上一个线程对state的修改对下一个线程是可见的。
 * 另外由于有if条件做判断，所以可以确保只有单一的线程修改变量state的值，这里用volatile就足够了。
 */
public class ABC1 {
    private static int n = 10 * 10000;// 控制线程执行次数
    private volatile static int state = 0; //控制线程执行条件

    static class ThreadA extends Thread {
        public void run() {
            for (int i = 0; i < n; ) {
                if (state % 3 == 0) {
                    System.out.println("A,loopNum=" + i);
                    state++;
                    i++;
                }
            }
        }
    }

    static class ThreadB extends Thread {
        public void run() {
            for (int i = 0; i < n; ) {
                if (state % 3 == 1) {
                    System.out.println("B,loopNum=" + i);
                    state++;
                    i++;
                }
            }
        }
    }

    static class ThreadC extends Thread {
        public void run() {
            for (int i = 0; i < n; ) {
                if (state % 3 == 2) {
                    System.out.println("C,loopNum=" + i);
                    state++;
                    i++;
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();
        new ThreadA().start();
        new ThreadB().start();
        ThreadC c = new ThreadC();
        c.start();
        c.join();
        long endTime = System.currentTimeMillis();
        System.out.println("n=" + n);
        System.out.println("RunTime is " + (double) (endTime - startTime) / 1000 + "s");
    }
}
//A,loopNum=0
//B,loopNum=0
//C,loopNum=0
//A,loopNum=1
//B,loopNum=1
//C,loopNum=1
//A,loopNum=2
//B,loopNum=2
//C,loopNum=2
//...
//A,loopNum=99999
//B,loopNum=99999
//C,loopNum=99999
//RunTime is 5.764s

返回索引

解法二

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 解法2:采用原子类AtomicInteger来控制变量state，其他不变
 */
public class ABC2 {
    private static int n = 10 * 10000;// 控制线程执行次数
    private static AtomicInteger state = new AtomicInteger(0); //控制线程执行条件

    static class ThreadA extends Thread {
        public void run() {
            for (int i = 0; i < n; ) {
                if (state.get() % 3 == 0) {
                    System.out.println("A,loopNum=" + i);
                    state.getAndIncrement();
                    i++;
                }
            }
        }
    }

    static class ThreadB extends Thread {
        public void run() {
            for (int i = 0; i < n; ) {
                if (state.get() % 3 == 1) {
                    System.out.println("B,loopNum=" + i);
                    state.getAndIncrement();
                    i++;
                }
            }
        }
    }

    static class ThreadC extends Thread {
        public void run() {
            for (int i = 0; i < n; ) {
                if (state.get() % 3 == 2) {
                    System.out.println("C,loopNum=" + i);
                    state.getAndIncrement();
                    i++;
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();
        new ThreadA().start();
        new ThreadB().start();
        ThreadC c = new ThreadC();
        c.start();
        c.join();
        long endTime = System.currentTimeMillis();
        System.out.println("RunTime is " + (double) (endTime - startTime) / 1000 + "s");
    }
}
//A,loopNum=0
//B,loopNum=0
//C,loopNum=0
//A,loopNum=1
//B,loopNum=1
//C,loopNum=1
//A,loopNum=2
//B,loopNum=2
//C,loopNum=2
//...
//A,loopNum=99999
//B,loopNum=99999
//C,loopNum=99999
//RunTime is 4.901s

返回索引

解法三


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

/**
 * 解法3：采用ReentrantLock锁住整段代码
 */
public class ABC3 {
    private static int n = 10 * 10000;// 控制线程执行次数
    private static int state = 0; // 控制线程执行条件
    private static Lock lock = new ReentrantLock();

    static class ThreadA extends Thread {
        public void run() {
            for (int i = 0; i < n; ) {
                lock.lock();
                if (state % 3 == 0) {
                    System.out.println("A,loopNum=" + i);
                    state++;
                    i++;
                }
                lock.unlock();
            }
        }
    }

    static class ThreadB extends Thread {
        public void run() {
            for (int i = 0; i < n; ) {
                lock.lock();
                if (state % 3 == 1) {
                    System.out.println("B,loopNum=" + i);
                    state++;
                    i++;
                }
                lock.unlock();
            }
        }
    }

    static class ThreadC extends Thread {
        public void run() {
            for (int i = 0; i < n; ) {
                lock.lock();
                if (state % 3 == 2) {
                    System.out.println("C,loopNum=" + i);
                    state++;
                    i++;
                }
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();
        new ThreadA().start();
        new ThreadB().start();
        ThreadC c = new ThreadC();
        c.start();
        c.join();
        long endTime = System.currentTimeMillis();
        System.out.println("RunTime is " + (double) (endTime - startTime) / 1000 + "s");
    }
}
//A,loopNum=0
//B,loopNum=0
//C,loopNum=0
//A,loopNum=1
//B,loopNum=1
//C,loopNum=1
//A,loopNum=2
//B,loopNum=2
//C,loopNum=2
//...
//A,loopNum=99999
//B,loopNum=99999
//C,loopNum=99999
//RunTime is 5.45s

返回索引

解法四

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

/**
 * 解法4：采用ReentrantLock，三个Condition进行await和signal操作
 */
public class ABC4 {
    private static int n = 10 * 10000;// 控制线程执行次数
    private static Lock lock = new ReentrantLock();
    private static Condition A = lock.newCondition();
    private static Condition B = lock.newCondition();
    private static Condition C = lock.newCondition();
    private static int state = 0;

    private static class ThreadA extends Thread {
        public void run() {
            lock.lock();
            try {
                for (int i = 0; i < n; i++) {
                    if (state % 3 != 0)
                        A.await();
                    System.out.println("A,loopNum=" + i);
                    state++;
                    B.signal();
                }
            } catch (InterruptedException e) {

                e.printStackTrace();
            } finally {
                lock.unlock();
            }

        }
    }

    static class ThreadB extends Thread {
        public void run() {
            lock.lock();
            try {
                for (int i = 0; i < n; i++) {
                    if (state % 3 != 1)
                        B.await();
                    System.out.println("B,loopNum=" + i);
                    state++;
                    C.signal();
                }
            } catch (InterruptedException e) {

                e.printStackTrace();
            } finally {
                lock.unlock();
            }

        }
    }

    static class ThreadC extends Thread {
        public void run() {
            lock.lock();
            try {
                for (int i = 0; i < n; i++) {
                    if (state % 3 != 2)
                        C.await();
                    System.out.println("C,loopNum=" + i);
                    state++;
                    A.signal();
                }
            } catch (InterruptedException e) {

                e.printStackTrace();
            } finally {
                lock.unlock();
            }

        }
    }

    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();
        new ThreadA().start();
        new ThreadB().start();
        ThreadC c = new ThreadC();
        c.start();
        c.join();
        long endTime = System.currentTimeMillis();
        System.out.println("RunTime is " + (double) (endTime - startTime) / 1000 + "s");
    }
}
//A,loopNum=0
//B,loopNum=0
//C,loopNum=0
//A,loopNum=1
//B,loopNum=1
//C,loopNum=1
//A,loopNum=2
//B,loopNum=2
//C,loopNum=2
//...
//A,loopNum=99999
//B,loopNum=99999
//C,loopNum=99999
//RunTime is 3.784s

返回索引

解法五

import java.util.concurrent.Semaphore;

/**
 * 解法5：使用信号量机制，完全不用state变量进行条件控制
 */
public class ABC5 {
    private static int n = 10 * 10000;
    private static Semaphore AB = new Semaphore(0);
    private static Semaphore BC = new Semaphore(0);
    private static Semaphore CA = new Semaphore(0);

    static class ThreadA extends Thread {

        @Override
        public void run() {
            try {
                for (int i = 0; i < n; i++) {
                    CA.acquire();
                    System.out.println("A,loopNum=" + i);
                    AB.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    static class ThreadB extends Thread {

        @Override
        public void run() {
            try {
                for (int i = 0; i < n; i++) {
                    AB.acquire();
                    System.out.println("B,loopNum=" + i);
                    BC.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    static class ThreadC extends Thread {

        @Override
        public void run() {
            try {
                for (int i = 0; i < n; i++) {
                    BC.acquire();
                    System.out.println("C,loopNum=" + i);
                    CA.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();
        CA.release(); //释放CA，让A线程先执行
        new ThreadA().start();
        new ThreadB().start();
        ThreadC c = new ThreadC();
        c.start();
        c.join();
        long endTime = System.currentTimeMillis();
        System.out.println("RunTime is " + (double) (endTime - startTime) / 1000 + "s");

    }
}
//A,loopNum=0
//B,loopNum=0
//C,loopNum=0
//A,loopNum=1
//B,loopNum=1
//C,loopNum=1
//A,loopNum=2
//B,loopNum=2
//C,loopNum=2
//...
//A,loopNum=99999
//B,loopNum=99999
//C,loopNum=99999
//RunTime is 3.672s

返回索引

Mars-xq

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java并发：多线程与volatile、AtomicInteger、ReentrantLock、Condition、Semaphore

参考：Java 每日算法，三个线程按顺序打印题目一启动3个线程A、B、C，使A打印0，然后B打印1，然后C打印2，A打印3，B打印4，C打印5，依次类推。/** * 启动3个线程A、B、C，使A打印0，然后B打印1，然后C打印2，A打印3，B打印4，C打印5，依次类推。 */public class PrintSequenceThread implements Runnable { ...
复制链接

扫一扫