【Java笔记】多线程2: 加锁小练习（卖票+交替打印+哲学家就餐）

已于 2024-04-21 12:52:45 修改
阅读量641 收藏 15
点赞数 21
分类专栏： Java 文章标签： java 笔记 开发语言
于 2024-04-19 23:14:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hansdas/article/details/137976094
版权
本文介绍了Java中的多线程实现方式，包括继承Thread、实现Runnable接口以及使用Callable/Future接口。详细讲解了如何使用synchronized进行线程同步，以及Lock接口的使用。并通过卖票和哲学家就餐问题的案例演示了死锁的概念和预防策略。
摘要由CSDN通过智能技术生成

文章目录


练习下Thread，Runnable，synchronized， Lock，稍微记录下

0. 稍微回顾点基础

0.1 如何起多线程

一般就是三种方式：

  1. Thread的类，
  2. Runnable接口
  3. Callable+FutureTask接口

0.1.1 继承Thread

主要就是重写run方法，实例化后调用Thread.start()开启线程

public class MyThread extends Thread{
    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 1000; i++) {
            System.out.println(getName()+": Hello MyThread!");
        }
    }
}
// ----------------------------------------
public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.setName("T1");
        MyThread t2 = new MyThread();
        t2.setName("T2");
        t1.start();
        t2.start();
    }
}

0.1.2 实现Runnable接口

实现run方法，并实例化作为参数传入Thread实例
最后也是通过调用Thread.start()开启线程

public class MyRun implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            Thread t = Thread.currentThread(); // 获取当前线程对象
            System.out.println(t.getName()+"Hello Runnable");
            // System.out.println(Thread.currentThread().getName()+"Hello Runnable");
        }
    }
}
// ---------------------------
public class Main {
    public static void main(String[] args) {
        // 创建MyRun对象，表示多线程要执行的任务
        MyRun myRun = new MyRun();
        // 创建线程对象
        Thread t1 = new Thread(myRun);
	    Thread t2 = new Thread(myRun);
        // 启动线程
        t1.start();
        t2.start();
    }
}

0.1.3 Callable接口+Future接口

最特别的就是可以获取多线程的运行结果，也就是run有返回值

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        // 求1-100和并返回
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += i;
        }
        return sum;
    }
}
// ---------------------------
public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable mc = new MyCallable();
        FutureTask<Integer> ft = new FutureTask<>(mc);
        Thread t1 = new Thread(ft);
        t1.start();
        int sum = ft.get();
        System.out.println(sum);
    }
}

0.2 如何加锁

主要就是synchronized修饰符或者Lock接口的实现类

0.2.1 synchronized

大概有需要注意几点：

  • synchronized是基于悲观锁的，当一个线程试图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁。
  • 锁对象：锁对象一定要唯一。
    • 可以设为本类的class对象，因为一个类的class对象是唯一的，哪怕有很多实例；
    • 也可以在类内增加一个static final的Object实例，也不一定是Object实例，只要是static保证所有类实例都相同，final保证不可更改，也就是一起确保了锁对象的唯一性。
    • 锁膨胀：无锁->偏向锁->轻量级锁->重量级锁

有两种用法：

  1. synchronized 同步代码块
synchronized(锁对象){
	...
}
  1. synchronized 同步方法
修饰符 synchronized 返回值类型 方法名(方法参数) {...}

注意一下，同步方法会锁住方法里的所有代码，并且锁对象不能自己指定：

  • 非静态方法：this，即当前方法的调用者。此时也叫方法锁
  • 静态方法：当前类的字节码文件。此时也叫类锁

0.2.2 Lock的实现类

比较常用的就是ReentranLock
需要自己手动上锁，一般会用try{要上锁的代码}finally{解锁}来保证所以定会被释放

Lock lock=new ReentrantLock();
lock.lock();
try{
	...
}finally{
	lock.unlock();
}

下面来看点案例练练手

1. 案例：卖电影票

1000张电影票，在两个窗口领取，每次领取一张，假设被刺领取的时间为3000ms
用多线程模拟卖票过程，并打印剩余电影票的数量

1.1 案例实现：Runnable接口

1.1.1 synchronized 同步代码块

Runnable实现类

// 实现Runnable接口+synchronized同步代码块
public class TicketRunnable1 implements Runnable {
    static int tickets = 1000;
//    定义一个锁对象,也可以用当前类的class对象
    private static Object lock = new Object();

    @Override
    public void run() {
        while (tickets > 0) {
            synchronized (lock) {
                if (tickets > 0) {
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(Thread.currentThread().getName() + " 卖出1张票，剩余电影票：" + --tickets);
                }
            }
        }
    }
}

1.1.2 synchronized 同步方法

就是把上面同步代码块抽出一个函数，并且不用自己制定锁对象

// 实现Runnable接口+synchronized同步方法
public class TicketRunnable2 implements Runnable{
    static int tickets = 1000;
    // 静态
    @Override
    public void run() {
        while(tickets > 0){
            sell();
        }
    }

    private synchronized void sell() {
        if (tickets > 0){
            try{
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName() + " 卖出1张票，剩余电影票：" + --tickets);
        }
    }
}

开两个线程测试

public class TestRunnable {
    // 1000张电影票，在两个窗口领取，假设被领取的时间为3000ms
    // 时间可以调小点，比如50ms，给cpu上点强度，可以更好体现出线程交替互斥的过程
    // 用多线程模拟卖票过程，并打印剩余电影票的数量
    public static void main(String[] args) {
//        TicketRunnable1 = new TicketRunnable1();
//        Thread window1 = new Thread(ticketRunnable1, "Window1");
//        Thread window2 = new Thread(ticketRunnable1, "Window2");
        TicketRunnable2 ticketRunnable2 = new TicketRunnable2();
        Thread window1 = new Thread(ticketRunnable2, "Window1");
        Thread window2 = new Thread(ticketRunnable2, "Window2");
        window1.start();
        window2.start();
    }
}

运行结果
在这里插入图片描述
没啥问题。
如果你想实例化两个runnable实现类也没问题，因为锁对象是唯一，比如下面这样

public class TestRunnable {
    // 1000张电影票，在两个窗口领取，假设被领取的时间为3000ms
    // 时间可以调小点，比如50ms，给cpu上点强度，可以更好体现出线程交替互斥的过程
    // 用多线程模拟卖票过程，并打印剩余电影票的数量
    public static void main(String[] args) {
        TicketRunnable1 ticketRunnable1 = new TicketRunnable1();
        TicketRunnable1 ticketRunnable11 = new TicketRunnable1();
        Thread window1 = new Thread(ticketRunnable1, "Window1");
        Thread window2 = new Thread(ticketRunnable11, "Window2");
        window1.start();
        window2.start();
    }
}

1.1.3 Lock手动上锁

// 实现Runnable接口+Lock
public class TicketRunnable3 implements Runnable{
    static int tickets = 1000;

    @Override
    public void run() {
        ReentrantLock lock = new ReentrantLock();
        while(tickets > 0){
            lock.lock();
            try {
                Thread.sleep(50);
                if (tickets > 0){
                    System.out.println(Thread.currentThread().getName() + " 卖出1张票，剩余电影票：" + --tickets);
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }
        }
    }
}

测试结果
在这里插入图片描述

1.2 案例实现：Thread

先写个Thread的继承类，这里就用同步方法写了，其他锁的办法也差不多，就不多讲咯

public class MyThread1 extends Thread{
    static int tickets = 1000;
    @Override
    public void run() {
        super.run();
        while (tickets > 0){
            sell();
        }
    }

    private static synchronized void sell() {
        if (tickets > 0){
            try{
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName() + " 卖出1张票，剩余电影票：" + --tickets);
        }
    }
}

需要注意的是，这里synchronized的方法sell()必须是静态的，
因为静态的同步方法的锁对象是当前类的字节码文件对象，
而非静态的同步方法的锁对象是this，也就是调用类的实例，这里我们需要实例化两个对象window1和window2，他们的锁对象是不同的，因此会出现不同步的问题，如下图
在这里插入图片描述
票卖的只剩-1了，明显线程间没有同步

2. 案例：两个线程交替打印0-100

这是之前牛客上看到个面试手撕题，用wait()和notifyAll()让线程等待与唤醒就行
先给段代码，大家可以思考一下对不对

public class Printer implements Runnable {
    private static int number = 0;
    int printId;

    public Printer(int printId) {
        this.printId = printId;
    }

    @Override
    public void run() {
        while (number <= 100) {
            printNum();
        }
    }

    private synchronized void printNum() {
        if (number % 2 != printId) {
            // 不是当前线程就等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        // 被唤醒后
        if (number <= 100) {
            System.out.println(Thread.currentThread().getName() + ": " + number++);
            this.notifyAll();
        }
    }
}

测试一下

public class Test {
    public static void main(String[] args) {
        Printer printer1 = new Printer(0);
        Printer printer2 = new Printer(1);
        Thread thread1 = new Thread(printer1);
        Thread thread2 = new Thread(printer2);
        thread1.start();;
        thread2.start();
    }
}

在这里插入图片描述
很明显，寄了。主要问题就出在代码里用的synchronized同步方法，因为我们是给两个线程一个printId（0或1）以便通过number的奇偶来判断该哪个线程打印，显然，我们需要实例化两个Runnable实现类的对象，前面也说了synchronized非静态同步方法的锁对象是this，也就是实例本身，因此这里其实是没有同步了。
那，是不是直接把这个要同步的printNum方法给static了就行了呢？
很遗憾，也不行，因为printNum方法需要用printId来判断是不是当前线程的回合，而printId是需要通过构造函数初始化的，不可以是static，所以这样直接用同步方法行不通。
换成同步代码块，加一个唯一的锁对象就行了

public class Printer implements Runnable {
    private static int number = 0;
    int printId;
    private static final Object lock = new Object();

    public Printer(int printId) {
        this.printId = printId;
    }

    @Override
    public void run() {
        while (number <= 100) {
            synchronized (lock){
                if (number % 2 != printId) {
                    // 不是当前线程就等待
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                // 被唤醒后
                if (number <= 100) {
                    System.out.println(Thread.currentThread().getName() + ": " + number++);
                    lock.notifyAll();
                }
            }
        }
    }
}

当然这个锁对象用当前类的字节码文件也可以

synchronized (Printer.class){
	...
	Printer.class.wait();
	...
	Printer.class.notifyAll();
}

结果没毛病
在这里插入图片描述
当然，lock手动加锁就没这些麻烦，记得unlock就好

3. 面试官：你来写个死锁吧（哲学家就餐问题）

这也是今天在牛客上看到的（第一次听到这种请求）
死锁，简单来说就是两个线程互相等对方释放锁资源，然后你等我我等你你等我我等你你等我我等你你等我我等你你等我我等你你等我我等你你等我我等你你等我我等你你等我我等你你等我我等你你等我我等你你等我我等你你等我我等你你等我我等你你等我我等你你等我我等你…一直等下去

public class Test {
    static Object lock1 = new Object();
    static Object lock2 = new Object();
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock1){
                System.out.println(Thread.currentThread().getName() + " get lock1!");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(Thread.currentThread().getName() + " wait lock2...");
                synchronized (lock2){
                    System.out.println(Thread.currentThread().getName() + " get lock2!");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock2){
                System.out.println(Thread.currentThread().getName() + " get lock2!");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(Thread.currentThread().getName() + " wait lock1...");
                synchronized (lock1){
                    System.out.println(Thread.currentThread().getName() + " get lock1!");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

启动一下
在这里插入图片描述
就一直在wait力。哲学家就餐问题来说，这里两个线程就是两个哲学家，两个锁就是两支筷子，只有凑够两支筷子才能吃上饭。

3.* 有关死锁

预防死锁

上面这个问题出现的很大一部分原因就是锁的嵌套，实际写代码的时候也要尽量避免这种情况来预防死锁。此外也有银行家算法之类的来评估预防死锁，但今天就先不展开了。

解除死锁

一般就是资源剥夺法，撤销进程法，进程回退法

  • 撤销进程：强制结束一个或多个进程并回收它们的资源，以打破死锁（比如直接kill掉）；
  • 进程回退：将一个或多个进程回退到某一安全状态，这些状态之前未涉及死锁。通过回退并重新计算资源分配，系统尝试解决死锁问题；
  • 资源剥夺：挂起/激活机制。挂起一些进程，剥夺它们的资源以解除死锁，待条件满足时，再激活进程。
    这里【进程回退】时其实也涉及到了【资源剥夺】
java练习题---线程
weixin_48079129的博客
10-13 260
解析： synchronized 关键字 : 用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这个段代码。 2. 解析：　 一个线程执行的过程有三个阶段： 加载（复制）主存数据到操作栈 --> 对操作栈数据进行修改 --> 将操作栈数据写回主存 volatite关键字，让编译器不去优化代码使用缓存等，以保证线程在“加载数据阶段”加载的数据都是最新的 ３. 解析：　同步器是一些使线程能够等待另一个线程的对象，允许它们协调动作。最常用的...
java编程思想学习笔记——21多线程
Burnup_110的博客
04-01 577
一、并发简介 实现并发最直接的方式是在操作系统级别使用进程。进程是运行在它自己的地址空间内的自包含的程序。多任务操作系统可以通过周期性地将CPU 从一个进程切换到另一个进程，来实现同时运行多个进程（程序）。对于进程来说，他们之间没有任何彼此通信的需要，因为他们都是完全独立的。 但是如果将进程当做并发的唯一选择，那么进程来做并发来说的话，也有他的局限性，因为进程通常来说是有数量和开销的限制的，以避免他们在不同的并发系统之间的可应用性 java采用在顺序型语言的基础上提供对线程的支持，即线程机制是在由执行程序表
Java多线程练习以及知识点总结
m0_63445035的博客
05-08 538
先对多线程这章的知识点进行总结，然后对这部分练习的问题的总结
Java基础编程500题——多线程
安晴晚风的博客
07-22 1392
Java基础编程500题——多线程
【JavaSE】多线程篇（五）线程专项练习题
黄小黄的博客
09-07 979
本文整理了一些多线程的练习题，包括取钱问题、通知终止线程的编程练习，判断与简答，供读者学习练习使用。
Java多线程的练习
Seven597的博客
04-04 775
Java的多线程线程类的部分方法有关方法1有关方法而2创建线程第一种创建线程的方式第二种创建线程的方式分析两种线程的创建线程的优先级优先级设置以及获取优先级的方法线程的生命周期图解线程的生命周期（参考尚硅谷视频）线程的同步同步的优缺点优点缺点同步代码块同步方法当使用 继承Thread的线程实现抢票功能时注意问题变量值使用同步代码块或者同步方法的时需要注意使用 ReentrantLock 线程锁解决同步带来的安全性问题线程同步出现死锁问题 线程类的部分方法 有关方法1 void start() : 启动线程
LeetCode（1226）：哲学家进餐 The Dining Philosophers（JUC）
NJU_ChopinXBP的博客
12-19 526
2020.12.19 LeetCode 从零单刷个人笔记整理（持续更新） github：https://github.com/ChopinXBP/LeetCode-Babel 传送门：哲学家进餐 Five silent philosophers sit at a round table with bowls of spaghetti. Forks are placed between each pair of adjacent philosophers. Each philosopher must alt
操作系统进程同步三大问题：生产者消费者，哲学家进餐，读者写者问题
ylf13的专栏
12-31 7056
对于非科班出身的我，，，最近自学操作系统做了一些进程同步的笔记，写出来，希望能对大家有帮助，我是参照哈工大张英涛老师的视频和汤子瀛的书写的： 进程与进程之间的合作机制： 信号量机制！！！ 信号量是一种数据结构。 信号量的值与相应资源的使用情况有关。 信号量的值仅由原语P、V操作改变   （1）整型信号量 整型数  S 0代表空闲可用 P操作(wait)原语 V操作（signal
uc笔记12---竞争与同步，互斥量，信号量，死锁，条件变量，哲学家就餐问题
wolfsun3的专栏
09-30 1216
1.    竞争与同步     当多个线程同时访问其所共享的进程资源时，需要相互协调，以防止出现数据不一致、不完整的问题；这就叫线程同步。     范例：vie.c         #include         #include         #include         unsigned int g_cn = 0;         void* thread_pr
《实战Java高并发程序设计》读书笔记
文剑木然的专栏
05-28 271
本文首发在我的个人博客：https://jlice.top/p/7t3gc/。欢迎大家前去参观，么么哒~ 这两天快速看了下《实战Java高并发程序设计》这本书，对Java高并发程序有一个初步的认识。 这本书是在iPad上用MarginNotes 3看的，只是做了些笔记，还没进行代码实践，后续还需要细化。 基础概念 并发偏重于多个任务交替执行，而多个任务之间有可能还是串行的，而并行是真正...
JAVA多线程练习题。
04-12
JAVA多线程练习题。都是一些基本的练习题。对初学者有帮助
java基础多线程练习题（1）
08-08
java基础之多线程的练习题，博客访问地址： http://blog.csdn.net/u014028392/article/details/76906801
JAVA多线程练习题答案。
04-13
JAVA多线程练习题的答案。都是一些基本的练习题。对初学者有帮助
java线程实践练习
12-26
主要增加有关java线程学习的资料，增加对java编程以及并发等相关知识点的理解，方便后续查阅
Java多线程练习题
11-21
这是对Java多线程的一些相关练习题 包括选择 填空 简答 编程等题型
Java 多线程练习 (2024.8.12)
最新发布
Aishangyuwen的博客
08-12 371
Java 多线程练习 (2024.8.12)
JAVA如何在线程中加锁（四种方法）
热门推荐
weixin_43907440的博客
04-22 3万+
JAVA多线程锁 线程的生命周期 ​ 总共六种状态，可归结为五种，线程的最终是死亡，阻塞不是最终状态，只是一个临时状态。只有调用了start方法，线程才进入就绪阶段。 //新生 ​ NEW, //运行​ RUNNABLE, //阻塞​ BLOCKED, //等待，死死地等​ WAITING, //超时等待​ TIMED_WAITING, //终止​ ...
Java 多线程练习
qq_57570052的博客
07-28 2552
1.定时器操作（实现电脑定时关机）。2.每个月的月末(02:00:00)执行一次代码3.模拟售票模拟了多个线程同时售票的场景，保证了并发环境下的票的售卖过程的正确性和一致性。4.用15个线程实现，求123456789之间放+-和为100的表达式（11结果），如果一个线程求出结果， 立即告诉其它停止。
13.JAVA中的线程（内含练习与代码解析）
改变从现在开始
08-04 229
线程的生命周期，控制，创建，以及死锁，线程池。（内含练习与代码）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值