Java 采用ReentrantLock和Synchronized实现多线程案例（哲学家就餐问题、多个线程交替打印、抢票案例）

已于 2023-06-30 08:55:28 修改
阅读量146 收藏
点赞数
分类专栏： 多线程 文章标签： java 开发语言
于 2023-06-21 15:15:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44785726/article/details/131328402
版权 

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



public class ThreadCaseTest {

    static ReentrantLock lock = new ReentrantLock();

    static final Object o = new Object(); //共享变量

    static volatile int num = 0; //volatile 多线程情况下保证数据的可见性

    static final int ticketNums = 100; //总票数

    static final int peopleSize = 200; //抢票人数

    static int ticketNum;//票数

    static int peopleNum;//人数

    static String code = "A"; //默认是A

    public static void main(String[] args) throws Exception {

        demo1();
        demo2();
        demo3();
        demo4();
        demo5();
        demo6();
        demo7();
        demo8();

    }

    /**
     * 8. 两个线程交替打印奇偶数。0-100
     */
    private static void demo8() {

        Condition a = lock.newCondition();
        Condition b = lock.newCondition();

        new Thread(() -> {
            while (num < 100) {
                try {
                    lock.lock();
                    if (num % 2 == 1) {
                        a.await();//当前线程等待
                    }
                    System.out.println(Thread.currentThread().getName() + num);
                    num++;
                    b.signal();//唤醒另一个线程
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();//释放锁
                }
            }
        }, "线程A: ").start();

        new Thread(() -> {
            while (num < 100) {
                try {
                    lock.lock();
                    if (num % 2 == 0) {
                        b.await();
                    }
                    System.out.println(Thread.currentThread().getName() + num);
                    num++;
                    a.signal();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }, "线程B: ").start();
    }

    /**
     * 7. 抢票案例
     */
    private static void demo7() {

        new TicketThread("窗口A").start();

        new TicketThread("窗口B").start();

        new TicketThread("窗口C").start();

        new TicketThread("窗口D").start();

    }

    /**
     * 6. 哲学家就餐问题
     */
    private static void demo6() {
        Chopsticks chopsticks0 = new Chopsticks();
        Chopsticks chopsticks1 = new Chopsticks();
        Chopsticks chopsticks2 = new Chopsticks();
        Chopsticks chopsticks3 = new Chopsticks();
        Chopsticks chopsticks4 = new Chopsticks();

        new Philosohper("哲学家1", 1, chopsticks0, chopsticks1).start();
        new Philosohper("哲学家2", 2, chopsticks1, chopsticks2).start();
        new Philosohper("哲学家3", 3, chopsticks2, chopsticks3).start();
        new Philosohper("哲学家4", 4, chopsticks3, chopsticks4).start();
        new Philosohper("哲学家5", 5, chopsticks4, chopsticks0).start();

    }

    /**
     * 5. 三个线程 a、b、c 并发运行，b,c 需要 a 线程的数据怎么实现
     */
    private static void demo5() {
        new Thread(() -> {
            try {
                //模拟耗时操作之后初始化变量 num
                Thread.sleep(1000);
                num = 1;
                System.out.println(Thread.currentThread().getName() + "获取到 num 的值为：" + num);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "线程A：").start();

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "获取到 num 的值为：" + num);
        }, "线程B：").start();

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "获取到 num 的值为：" + num);
        }, "线程C：").start();
    }

    /**
     * 4. 三个线程的Name分别是A，B，C；每个线程将自己的Name在控制台上打印5遍，打印顺序是ABC ABC...
     */
    private static void demo4() {

        Condition a = lock.newCondition();
        Condition b = lock.newCondition();
        Condition c = lock.newCondition();

        printA(a, b);

        printB(b, c);

        printC(c, a);

    }

    /**
     * 3. 写两个线程，一个线程打印1~ 52，另一个线程打印A~Z，打印顺序是12A34B...5152Z
     * 字母个数：26 A~Z。大写字母的A是65开始的，对应ASCII码表
     */
    private static void demo3() {

        new Thread(() -> {
            synchronized (o) {
                try {
                    while (num < 52) {
                        num++;
                        System.out.println(Thread.currentThread().getName() + num);
                        if (num % 2 == 0) {
                            o.notify();
                            o.wait();
                        }
                    }
                    o.notify();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "线程A：").start();

        new Thread(() -> {
            synchronized (o) {
                try {
                    for (int i = 0; i < 26; i++) {
                        System.out.println(Thread.currentThread().getName() + (char) (65 + i));
                        o.notify();
                        o.wait();
                    }
                    o.notify();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "线程B：").start();
    }

    /**
     * 2. 两个线程轮流打印数字，一直到100。t1：1，t2：2；t1：3，t2：4；......
     */
    private static void demo2() {

        new Thread(() -> {
            synchronized (o) {
                while (num < 100) {
                    try {
                        num++;
                        System.out.println(Thread.currentThread().getName() + num);
                        o.notify();
                        o.wait();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                o.notify();
            }
        }, "线程A: ").start();

        new Thread(() -> {
            synchronized (o) {
                while (num < 100) {
                    try {
                        num++;
                        System.out.println(Thread.currentThread().getName() + num);
                        o.notify();
                        o.wait();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                o.notify();
            }
        }, "线程B: ").start();
    }

    /**
     * 1. 要求线程a执行完才开始线程b, 线程b执行完才开始线程c
     *
     * @throws Exception
     */
    private static void demo1() throws Exception {

        PrintThread threadA = new PrintThread("A");
        PrintThread threadB = new PrintThread("B");
        PrintThread threadC = new PrintThread("C");

        threadA.start();
        threadA.join();

        threadB.start();
        threadB.join();

        threadC.start();
        threadC.join();
    }

    static class PrintThread extends Thread {

        PrintThread(String name) {
            super(name);
        }

        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }

    private static void printA(Condition a, Condition b) {
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                lock.lock();
                try {
                    if (!code.equalsIgnoreCase("A")) a.await();
                    System.out.println(Thread.currentThread().getName() + i);
                    code = "B";
                    b.signal();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }, "线程A：").start();
    }

    private static void printB(Condition b, Condition c) {
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                lock.lock();
                try {
                    if (!code.equalsIgnoreCase("B")) b.await();
                    System.out.println(Thread.currentThread().getName() + i);
                    code = "C";
                    c.signal();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }, "线程B：").start();
    }

    private static void printC(Condition c, Condition a) {
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                lock.lock();
                try {
                    if (!code.equalsIgnoreCase("C")) c.await();
                    System.out.println(Thread.currentThread().getName() + i);
                    code = "A";
                    a.signal();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }, "线程C：").start();
    }

    static class Philosohper extends Thread {

        private String name;//名字
        private int num;//编号
        private Chopsticks left, right;//筷子

        Philosohper(String name, int num, Chopsticks left, Chopsticks right) {
            this.name = name;
            this.num = num;
            this.left = left;
            this.right = right;
        }

        @Override
        public void run() {
            if (num % 2 == 0) { //假设有人是左撇子
                synchronized (left) {
                    try {
                        sleep(1000);
                        synchronized (right) {
                            System.out.println("编号为：" + num + " 名字为：" + name + " 开始吃饭了");
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            } else {
                synchronized (right) {
                    try {
                        sleep(1000);
                        synchronized (left) {
                            System.out.println("编号为：" + num + " 名字为：" + name + " 开始吃饭了");
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }

        }
    }

    static class Chopsticks {

    }

    static class TicketThread extends Thread {

        private String windowName;

        TicketThread(String windowName) {
            this.windowName = windowName;
        }

        @Override
        public void run() {
            synchronized (o) {
                while (ticketNum < ticketNums && peopleNum < peopleSize) {
                    if (peopleNum % 2 == 1) {
                        System.out.println(windowName + " " + Thread.currentThread().getName() + " 第" + (++peopleNum) + "个人抢到第" + (++ticketNum) + " 张票");
                        try {
                            Thread.sleep(100);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    } else {
                        System.out.println(windowName + " " + Thread.currentThread().getName() + " 第" + (++peopleNum) + " 个人未抢到票");
                    }
                }
            }
        }

    }

}

Jokes-T
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程java代码实例[7个例子]
White
07-23 4497
1 线程创建 1）继承Thread类方式 代码： package com.whl.thread; /** * 注: * java.lang包中放着java最核心最基础的类、接口：Object、System、Thread、Runnable * Thread.currentThread()获取当前cpu执行线程 */ public class TestThread { public static void main(String[] args) { /** *
JAVA中线程同步的基本解释与示例
2301_76679920的博客
05-14 98
在上面的例子中，我们使用了ReentrantLock类来实现线程同步，使用lock()方法获取锁定，使用unlock()方法释放锁定，保证了对count变量的访问是线程安全的。另外，ReentrantLock类也可以用于实现线程同步，它提供了更灵活的锁定机制，支持公平锁和非公平锁，还可以控制线程的等待时间等。线程同步是指为了保证多个线程在访问共享资源时的安全性而采取的一种机制，它可以有效避免多线程之间的竞争关系，确保数据的一致性和正确性。
使用synchronized同步实现窗口抢票
qq_43655504的博客
04-15 330
使用同步实现窗口抢票 不使用同步的话可能会出现重票或负票的情况 线程有可能和其他线程共享一些资源，比如，内存，文件，数据库等。 当多个线程同时读写同一份共享资源的时候，可能会引起冲突。这时候，我们需要引入线程“同步”机制，即各位线程之间要有个先来后到，不能一窝蜂挤上去抢作一团。 线程同步的真实意思和字面意思恰好相反。线程同步的真实意思，其实是“排队”：几个线程之间要排队，一个一个对共享资源进行操作，而不是同时进行操作。 当多个线程要处理共享资源时，使用同步，但同步不应该过多使用，容易造成死锁
多线程代码块同步——抢火车票
ypf3442354429的博客
05-19 572
用之前学习的线程方法去写(有bug): package com.ytzl.第3章.dmeo1多线程.two; /*多线程之同步代码块*/ /*模拟网络抢票*/ public class one implements Runnable{ private int count=10;//记录抢票次数 private int num=0;//记录买到第几张票 public static void main(String[] args) { one site = ne.
Java - 多线程+锁机制实现简单模拟抢票
都随它大小便吧
08-31 1231
锁是一种同步机制，用于控制对共享资源的访问。锁的作用是确保同一时间只有一个线程可以访问共享资源，也就是说保证了线程安全。因此在并发编程中，锁是相当重要的。
Java多线程通信:交替打印ABAB实例
09-07
在这个场景下，我们关注的是如何实现两个线程交替打印"A"和"B"，形成"ABABAB"这样的序列。 在给出的示例中，我们创建了一个`PrintAB`类，包含两个方法`printA()`和`printB()`，这两个方法都是`synchronized`的，...
java采用多线程实现抢红包程序完整源码
10-08
3. **同步机制**：在并发环境中，为了防止多个线程对同一资源的不正确访问，Java提供了多种同步机制，如`synchronized`关键字、`Lock`接口（如`ReentrantLock`）等。在抢红包程序中，确保红包分配的公平性和准确性至...
Java多线程 ReentrantLock互斥锁详解
08-25
Java多线程ReentrantLock互斥锁详解 ...ReentrantLock是Java多线程编程中的一种锁机制，提供了加锁和解锁的方法，可以实现线程之间的同步访问资源。ReentrantLock的使用可以避免死锁的出现，提高程序的可靠性和稳定性。
Java 多线程synchronized关键字详解(六)
09-03
Java中的`synchronized`关键字是多线程编程中的一个重要概念，用于控制并发访问共享资源，以避免数据不一致和竞态条件。在这个问题中，我们将深入理解`synchronized`的关键字用法，包括同步方法和同步块。 1. **...
java基本教程之synchronized关键字 java多线程教程
09-04
【Java基本教程之synchronized关键字】在Java编程中，synchronized是用于控制多线程并发访问共享资源的关键字，确保了线程的安全性。本文将深入讲解synchronized的原理、基本规则以及其在方法和代码块中的应用。 1....
synchronized站点抢票同步例题
weixin_34125592的博客
04-12 184
多线程环境安全问题的判断标准（一定要三个同时满足） 是否是多线程环境 是否有共享数据 是否有多条语句操作(修改)共享数据 为什么出问题： CPU的一次操作必须是原子性的，在一个时间点，CPU只能执行一条指令，而一条语句是由多条指令组成的，比如说i++指令，CPU要先执行i+1,然后将i+1的值赋给i，然后再输出。我们用一条语句来理解，比如下面的卖票程序，当A站点输出语句“A站点还剩88...
【Java线程安全】 synchronized同步方法、同步块：模拟抢票、模拟取款
热门推荐
寒泉
07-28 1万+
synchronized的使用 1、同步方法 要注意的是，synchronized锁的不是方法，而是对象的资源。 33行，成员方法锁的是this，也就是p，方法中使用的资源必须都是对象p的资源，才能正确的锁住。 package cn.hanquan.test; public class Test { public static void main(String[] args) throws ...
【Java多线程】交替打印奇偶数
Nonoas的博客
06-23 1649
使用 ReentrantLock 结合 Condition 实现奇数偶数的交替打印
synchronized抢票线程只有一个问题
qq_44761778的博客
11-16 226
synchronized 抢票
ReentrantLock详解
weixin_44906791的博客
04-29 1140
ReentrantLock是一种可重入的独占锁，它允许同一个线程多次获取同一个锁而不会被阻塞。它的功能类似于synchronized是一种互斥锁，可以保证线程安全。可中断可以设置超时时间可以设置为公平锁支持多个条件变量与 synchronized 一样，都支持可重入它的主要应用场景是在多线程环境下对共享资源进行独占式访问，以保证数据的一致性和安全性。示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。
三种方式模拟两个线程抢票【最全版】
最新发布
kologin的博客
02-01 2988
在多线程编程中，资源竞争是一个常见的问题。资源竞争发生在多个线程试图同时访问或修改共享资源时，可能导致数据不一致或其他并发问题。在模拟两个线程抢票的场景中，我们需要考虑如何公平地分配票，并确保每个线程都有机会成功获取票。本篇文章将通过三种方式来模拟两个线程抢票的过程，以展示不同的并发控制策略。使用 Synchronized 来确保一次只有一个线程可以访问票资源。使用 ReentrantLock 来实现线程间的协调。使用 Semaphore 来限制同时访问票的线程数量。
Java多线程程序：多线程模拟抢票
Dream_chang的博客
07-26 2358
synchronized方法锁，锁定一个线程，不被其他线程抢用，用return返回值返回到while循环的语句中，然后根据true和false判断，来执行程序和终止程序。
Java——线程安全（synchronized解决线程安全问题，窗口售票为例）
挣钱买房买车的博客
08-01 994
Java——线程安全（synchronized解决线程安全问题，窗口售票为例）
Java多线程案例及其代码实现
weixin_59771320的博客
03-28 8468
目录 案例一：单例模式 1.饿汉模式的代码实现 2.懒汉模式 案例二：阻塞队列 1.线程安全 2.产生阻塞效果 1.如果队列为空，尝试出队列，就会出现阻塞现象，阻塞到队列不为空为止。 2.如果队列未满，尝试入队列，也会出现阻塞，阻塞到队列不为满为止。 案例三：定时器 1.描述任务 2.组织任务（使用一定的数据结构把这些任务给放到一起） 3.执行时间到了的任务 案例四：线程池 案例一：单例模式 线程安全的单例模式有两种典型实现： 1.饿...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值