Java ReentrantLock 实现两线程三线程交替输出

最新推荐文章于 2023-03-22 17:06:06 发布

.inevitable

最新推荐文章于 2023-03-22 17:06:06 发布

阅读量184

点赞数 1

分类专栏： 2023年1月文章标签： java 开发语言 spring

本文链接：https://blog.csdn.net/qq_40670452/article/details/128574719

版权

2023年1月专栏收录该内容

5 篇文章 0 订阅

订阅专栏

代码示例展示了如何使用Java的ReentrantLock和Condition或LockSupport来实现两个及三个线程交替输出数字1到最大值的场景。线程通过等待和通知机制确保按顺序打印，并在达到最大值时停止。

摘要由CSDN通过智能技术生成

两线程交替输出123456直到最大值

package org.example;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;

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

@Slf4j(topic = "c.Main")
public class Test {
    private static ReentrantLock lock = new ReentrantLock();
    private static boolean isPrint = false;
    private static int count = 0;
    private final static int MAX_COUNT = 30;
    @SneakyThrows
    public static void main(String[] args) {
        Condition condition = lock.newCondition();
        new Thread(() -> {
            while (count < MAX_COUNT) {
                lock.lock();
                while (!isPrint) {
                    try {
                        condition.await();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                log.debug("{}", count);
                count++;
                isPrint = !isPrint;
                condition.signal();
                lock.unlock();
            }
        }, "t1").start();

        new Thread(() -> {
            while (count < MAX_COUNT) {
                lock.lock();
                while (isPrint) {
                    try {
                        condition.await();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                log.debug("{}", count);
                count++;
                isPrint = !isPrint;
                condition.signal();
                lock.unlock();
            }
        }, "t2").start();
    }
}

三线程交替输出123456直到最大值

package org.example;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.locks.ReentrantLock;

@Slf4j(topic = "c.Main")
public class Test {
    private static ReentrantLock lock = new ReentrantLock();

    private static Condition condition1 = lock.newCondition();
    private static Condition condition2 = lock.newCondition();
    private static Condition condition3 = lock.newCondition();

    private static int count = 1;
    private final static int MAX_COUNT = 30;

    private static int currPrint = 1;
    private final static int PRINT_SIZE = 3;
    @SneakyThrows
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (count < MAX_COUNT) {
                lock.lock();
                while (currPrint != 1) {
                    try {
                        condition1.await();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                log.debug("{}", count);
                count ++;
                currPrint ++;
                condition2.signal();
                lock.unlock();
            }
        }, "1");
        Thread t2 = new Thread(() -> {
            while (count < MAX_COUNT) {
                lock.lock();
                while (currPrint != 2) {
                    try {
                        condition2.await();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                log.debug("{}", count);
                count ++;
                currPrint ++;
                condition3.signal();
                lock.unlock();
            }
        }, "2");
        Thread t3 = new Thread(() -> {
            while (count < MAX_COUNT) {
                lock.lock();
                while (currPrint != 3) {
                    try {
                        condition3.await();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                log.debug("{}", count);
                count ++;
                currPrint ++;
                currPrint %= PRINT_SIZE;
                condition1.signal();
                lock.unlock();
            }
        }, "3");

        t1.start();
        t2.start();
        t3.start();
    }
}

package org.example;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.locks.ReentrantLock;

@Slf4j(topic = "c.Main")
public class Test {
    private static int count = 1;
    private final static int MAX_COUNT = 30;

    private static int currPrint = 1;
    private final static int PRINT_SIZE = 3;

    private static Thread t1;
    private static Thread t2;
    private static Thread t3;

    @SneakyThrows
    public static void main(String[] args) {
        t1 = new Thread(() -> {
            while (count < MAX_COUNT) {
                while (currPrint != 1) {
                    LockSupport.park();
                }
                log.debug("{}", count);
                count++;
                currPrint++;
                LockSupport.unpark(t2);
            }
        }, "1");

        t2 = new Thread(() -> {
            while (count < MAX_COUNT) {
                while (currPrint != 2) {
                    LockSupport.park();
                }
                log.debug("{}", count);
                count++;
                currPrint++;
                LockSupport.unpark(t3);
            }
        }, "2");

        t3 = new Thread(() -> {
            while (count < MAX_COUNT) {
                while (currPrint != 3) {
                    LockSupport.park();
                }
                log.debug("{}", count);
                count++;
                currPrint++;
                currPrint %= PRINT_SIZE;
                LockSupport.unpark(t1);
            }
        }, "3");

        t1.start();
        t2.start();
        t3.start();
    }
}