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

已于 2024-04-21 12:52:45 修改
阅读量599 收藏 15
点赞数 21
分类专栏： Java 文章标签： java 笔记 开发语言
于 2024-04-19 23:14:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hansdas/article/details/137976094
版权

文章目录


练习下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掉）；
  • 进程回退：将一个或多个进程回退到某一安全状态，这些状态之前未涉及死锁。通过回退并重新计算资源分配，系统尝试解决死锁问题；
  • 资源剥夺：挂起/激活机制。挂起一些进程，剥夺它们的资源以解除死锁，待条件满足时，再激活进程。
    这里【进程回退】时其实也涉及到了【资源剥夺】
Hansdas
关注
  • 21
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java编程思想学习笔记——21多线程
Burnup_110的博客
04-01 310
一、并发简介 实现并发最直接的方式是在操作系统级别使用进程。进程是运行在它自己的地址空间内的自包含的程序。多任务操作系统可以通过周期性地将CPU 从一个进程切换到另一个进程，来实现同时运行多个进程（程序）。对于进程来说，他们之间没有任何彼此通信的需要，因为他们都是完全独立的。 但是如果将进程当做并发的唯一选择，那么进程来做并发来说的话，也有他的局限性，因为进程通常来说是有数量和开销的限制的，以避免他们在不同的并发系统之间的可应用性 java采用在顺序型语言的基础上提供对线程的支持，即线程机制是在由执行程序表
LeetCode（1226）：哲学家进餐 The Dining Philosophers（JUC）
NJU_ChopinXBP的博客
12-19 387
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
Java多线程总结
热门推荐
琦彦
02-07 1万+
前言Java语言一个重要的特点就是内置了对并发的支持，让Java大受企业和程序员的欢迎。在典型的Java面试中， 面试官会从线程的基本概念问起,  如：为什么你需要使用线程， 如何创建线程，用什么方式创建线程比较好（比如：继承thread类还是调用Runnable接口），然后逐渐问到并发问题像在Java并发编程的过程中遇到了什么挑战，Java内存模型，JDK1.5引入了哪些更高阶的并发工具，并发编...
个人多线程与并发与精通笔记
qq_36280879的博客
06-21 237
最主要就是提高 CPU 的利用率多线程程序可以充分使用 CUP 的效率避免无效等待（IO 的时候可以做别的事）提高用户体验：避免卡顿，缩短等待时间并行处理：提高性能，通常是在服务器领域（例如 Tomcat），用多个线程去接收进来的 HTTP 请求，而不是排队等待单一的线程处理在 Android 开发中，主线程的重要任务之一就是绘制屏幕界面，该线程中不允许进行 IO 操作或网络请求，目的就是避免卡顿，影响用户的交互串行和并行并发和并行概念非常相似并发：这里是单核 CPU(1 核），A、B、C 任务分次调度，这
多线程笔记
nate_18163126的博客
11-30 238
多线程 概念 进程(process) 是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程:有它自身的产生、存在和消亡的过程。——生命周期 程序是静态的，进程是动态的 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 线程(thread) 进程可进一步细化为线程，是一个程序内部的一条执行路径。 若一个进程同一时间并行执行多个线程，就是支持多线程的 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小 一个进程中的多个线程共享相同的内存单元/内存
学习笔记5(模拟3个经典多线程问题)
weixin_44237327的博客
06-26 196
多线程3个实例 利用信号量解决以下3个经典多线程问题 分别为 生产者-消费者问题 写者-读者问题 哲学家就餐问题 生产者-消费者 假定在生产者和消费者之间的公用缓冲区中具有n个缓冲区，这时可利用互斥信号量mutex实现诸进程对缓冲区的互斥使用：利用信号量empty和full分别表示缓冲池中空缓冲区和满缓冲区的数量。又假定这些生产者和消费者相互等效，只要缓冲池未满，生产者便可将任务送入缓冲区，只要缓冲池未空，消费者便可从缓冲区中取走一个任务。 主体思路就是设置3个信号量，分别代表缓冲区满，缓冲区空和互斥信号量
学习笔记：Java 并发编程②_管程
做笔记，记录学习中遇到的问题。
12-25 751
本博客内容：共享问题分析；synchroinzed；线程安全分析；Monitor；wait / notify；Park / Unpark；分析线程状态的转换；活跃性；ReentrantLock。
哲学家进餐问题的模拟【操作系统】
@MIKE小助手
05-11 2511
文章目录一、设计目的二、设计内容三、开发环境四、分析设计【1】实验原理【2】数据及程序结构 一、设计目的 死锁是进程并发执行过程中可能出现的现象，所谓死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局。哲学家就餐问题是描述死锁的经典例子。为了防止死锁，可以采用资源预分配法或者资源按序分配法。资源预分配法是指进程在运行前一次性地向系统申请它所需要的全部资源，如果系统当前不能够满足进程的全部资源请求，则不分配资源, 此进程暂不投入运行，如果系统当前能够满足进程的全部资源请求, 则一次性地将所申请的资源全
JUC并发编程笔记（上）多线程基础知识、Synchronized优化、ReentrantLock
[爪洼ing]的博客
10-10 236
JUC并发编程 一、前言篇 一、进程和线程 进程：进程是资源分配的最小单位 线程：线程是CPU调度的最小单位，一个进程中可以包含多个线程 二、并发和并行 并发：同一时间，应对多件事情的能力；例如：多个线程争抢一个CPU核心 ； 并线：同一时间，做多件事情的能力；例如：CPU有两个核心，同一时间，线程1和线程2分别用着2个核心！ 三、同步和异步 同步：需要等待结果的返回，同步运行 异步：不需要等待结果的返回，异步运行 多线程能否提升效率？ 对于单核来说，并不会提升效率，这种情况开多个线程依旧是一个核心再运
Java多线程详解（超详细）_狂神说笔记完整版_项目代码_适合小白随课程学习
08-08
学习目录：1. 线程简介 2. 线程实现（重点） 3. 线程状态 4. 线程同步（重点） 5. 线程通信问题 6. 高级主题
Java多线程+网银取款案例精讲
06-10
课程简介本课程是《Java初级至应用》系统课程的第十章，全套课程精细讲解，课程超过其他机构30%的课程量，经过我们全套课程系统学习的同学，可轻松从事Java工程师或系统架构师岗位，课程提供全套代码笔记其它相关...
Web前端学习笔记：HTML5+CSS3+JavaScript.pdf
03-19
Web前端学习笔记：HTML5+CSS3+JavaScript.pdf
j7cc:Java 7 Concurrency Cookbook 翻译+学习笔记
06-20
j7cc Java 7 Concurrency Cookbook 翻译+学习笔记
小程序源码 云笔记 (代码+截图)
06-19
小程序源码 云笔记 (代码+截图)小程序源码 云笔记 (代码+截图)小程序源码 云笔记 (代码+截图)小程序源码 云笔记 (代码+截图)小程序源码 云笔记 (代码+截图)小程序源码 云笔记 (代码+截图)小程序源码 云笔记 (代码+...
jar包增量更新分析
最新发布
junlaiyan的专栏
05-16 276
借助jdeps分析出jar包的增量文件
Spring-Cloud 微服务
weixin_65127444的博客
05-15 907
先来思考一个问题*通过上一章的操作，我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址（ip，端口）等硬编码到了代码中，这种做法存在许多问题：1.一旦服务提供者地址变化，就需要手工修改代码2. 一旦是多个服务提供者，无法实现负载均衡功能3.一旦服务变得越来越多，人工维护调用关系困难那么应该怎么解决呢，这时候就需要通过注册中心动态的实现。
java实现拼图小游戏
monkey108的博客
05-16 638
本文主要提供用java实现的拼图小游戏源代码。
命令执行漏洞（二）
XLbb的博客
05-15 911
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
Java多线程编程学习笔记之十二：生产者—消费者模型（含代码）
06-02
好的，下面是Java多线程编程学习笔记之十二：生产者—消费者模型的相关内容和代码。 ## 生产者—消费者模型简介 生产者—消费者模型是一种常见的多线程并发模型，它涉及到两个角色：生产者和消费者。生产者负责...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值