JAVA面向对象-----多线程 3

最新推荐文章于 2022-04-26 12:20:59 发布
最新推荐文章于 2022-04-26 12:20:59 发布
阅读量117 收藏 2
点赞数 3
分类专栏： JAVA学习 文章标签： 多线程 java 多进程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37453637/article/details/117035567
版权

多线程 3

线程的死锁问题

什么是死锁？

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁；出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。

如何解决死锁？

➢ 专门的算法、原则
➢ 尽量减少同步资源的定义
➢ 尽量避免嵌套同步

死锁演示

示例代码1：

public class ThreadTest_7 {
    public static void main(String[] args) {
        StringBuffer stringBuffer1 = new StringBuffer();
        StringBuffer stringBuffer2 = new StringBuffer();

        new Thread(){
            @Override
            public void run(){
                synchronized (stringBuffer1){
                    stringBuffer1.append("A");
                    stringBuffer2.append("1");

                    synchronized (stringBuffer2){
                        stringBuffer1.append("B");
                        stringBuffer2.append("2");
                        System.out.println(stringBuffer1);
                        System.out.println(stringBuffer2);
                    }
                }
            }
        }.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (stringBuffer2){
                    stringBuffer1.append("C");
                    stringBuffer2.append("3");

                    synchronized (stringBuffer1){
                        stringBuffer1.append("D");
                        stringBuffer2.append("4");
                        System.out.println(stringBuffer1);
                        System.out.println(stringBuffer2);
                    }
                }
            }
        }).start();

    }
}

运行结果：
在这里插入图片描述
示例代码2：

public class ThreadTest_7 {
    public static void main(String[] args) {
        StringBuffer stringBuffer1 = new StringBuffer();
        StringBuffer stringBuffer2 = new StringBuffer();

        new Thread(){
            @Override
            public void run(){
                synchronized (stringBuffer1){
                    stringBuffer1.append("A");
                    stringBuffer2.append("1");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (stringBuffer2){
                        stringBuffer1.append("B");
                        stringBuffer2.append("2");
                        System.out.println(stringBuffer1);
                        System.out.println(stringBuffer2);
                    }
                }
            }
        }.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (stringBuffer2){
                    stringBuffer1.append("C");
                    stringBuffer2.append("3");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (stringBuffer1){
                        stringBuffer1.append("D");
                        stringBuffer2.append("4");
                        System.out.println(stringBuffer1);
                        System.out.println(stringBuffer2);
                    }
                }
            }
        }).start();
    }
}

运行结果：
在这里插入图片描述
对比发现，示例代码2中加入了sleep()后，由于一个线程进入阻塞后，另一个线程立即进入，两个线程之间相互等待对方结束线程，导致死锁问题的产生~ ~

同步锁

Lock(锁)的概念

从JDK 5.0开始，Java提供了更强大的线程同步机制，通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
ReentrantLock 类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

代码演示

参考代码：

public class Lock_test {
    public static void main(String[] args) {
        Window window = new Window();
        Thread window1 = new Thread(window);
        Thread window2 = new Thread(window);
        Thread window3 = new Thread(window);
        window1.setName("窗口1");
        window2.setName("窗口2");
        window3.setName("窗口3");
        window1.start();
        window2.start();
        window3.start();
    }
}

class Window implements Runnable{
    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock(); //默认false
    @Override
    public void run() {
        while(true) {
            try {
                //2.调用锁定方法:lock()
                lock.lock();
            if (ticket > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                ticket--;
            } else {
                break;
            }
        }finally{
                //3.调用解锁方法：unlock()
                lock.unlock();
            }
        }
    }
}

运行结果：
在这里插入图片描述

synchronized 和 lock 的异同？

相同:
二者都可以解决线程安全问题~~

不同:

  1. Lock是显式锁(手动开启和关闭锁，别忘记关闭锁)，synchronized是隐式锁，出了作用域自动释放；
  2. Lock只有代码块锁，synchronized有代码块锁和方法锁；
  3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类）

优先使用顺序:

Lock----->同步代码块(已经进入了方法体，分配了相应资源) ----->同步方法中(在方法体之外) ~~

练习

银行有一个账户。有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打印账户余额。问题:该程序是否有安全问题，如果有，如何解决?
[提示]
1，明确哪些代码是多线程运行代码，须写入run()方法
2，明确什么是共享数据。
3，明确多线程运行代码中哪些语句是操作共享数据的。

参考代码：

public class AccountTest  {
    public static void main(String[] args) {
        Account account = new Account(0);
        Customer customer1 = new Customer(account);
        Customer customer2 = new Customer(account);

        customer1.setName("老公");
        customer2.setName("老婆");

        customer1.start();
        customer2.start();
    }
}

class Account{
    private double balance;
    public Account(double balance) {
        this.balance = balance;
    }
    //存钱
    public synchronized void deposit(double amt){
        if (amt>0){
            balance += amt;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":存钱成功，余额为："+ balance);
        }
    }
}

class Customer extends Thread{
    private Account account;

    public Customer(Account account) {
        this.account = account;
    }
    @Override
    public void run(){
        for (int i=0;i<5;i++){
            account.deposit(1000);
        }
    }
}

运行结果：
在这里插入图片描述

线程的通信

概述

线程通信的目的是为了能够让线程之间相互发送信号。另外，线程通信还能够使得线程等待其它线程的信号，比如，线程B可以等待线程A的信号，这个信号可以是线程A已经处理完成的信号。

线程通信涉及的方法

  1. wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
  2. notify()：一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait,就唤醒优先级高的线程。
  3. notifyALl()：一旦执行此方法，就会唤醒所有被wait的线程。

说明:

  1. wait(), notify(), notifyAll()三个方法必须使用在同步代码块或同步方法中。
  2. wait(), notify(), notifyALl()三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则，会出现IllegalMonitorStateException异常。
  3. wait(), notify(), notifyALl()三个方法是定义在java. Lang. object类中。

练习

例题：使用两个线程打印1-100，线程1和线程2交替打印。

参考代码：

public class ThreadCommunicateTest {
    public static void main(String[] args) {
        Number number = new Number();
        Thread thread1 = new Thread(number);
        Thread thread2 = new Thread(number);
        thread1.setName("线程1");
        thread2.setName("线程2");
        thread1.start();
        thread2.start();
    }
}

class Number implements Runnable{
    private int number = 1;
    @Override
    public void run() {
        while(true){
            synchronized (this){
                //将阻塞的进程唤醒
                notify();
                if (number<100){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+number);
                    number++;
                    try {
                        //使得调用如下wait()方法的线程进入阻塞状态
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    break;
                }
            }
        }
    }
}

运行结果：
在这里插入图片描述
sleep()方法和wait()方法的异同？
答：

相同点： 一旦执行方法，都会使得当前线程进入阻塞状态。
不同点：

  1. 两个方法声明的位置不同: Thread类中声明sLeep()，object 类中声明wait()；
  2. 调用的要求不同： sleep() 可以在任何需要的场景下调用。wait() 必须使用在同步代码块或同步方法中；
  3. 关于是否释放同步监视器:如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。

经典问题：生产者/消费者问题

题目描述：

生产者(Prpocuctor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20)，如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产;如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。

这里可能出现两个问题：

➢ 生产者比消费者快时，消费者会漏掉一些数据没有取到。
➢ 消费者比生产者快时，消费者会取相同的数据。

参考代码：

public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producer producer1 = new Producer(clerk);
        producer1.setName("生产者");
        Consumer consumer1 = new Consumer(clerk);
        consumer1.setName("消费者");
        producer1.start();
        consumer1.start();
    }
}

class Clerk{
    private int productCount = 0;
    //生产产品
    public synchronized void produceProduct() {
        if (productCount < 20){
            productCount++;
            System.out.println(Thread.currentThread().getName()+":开始生产第"+productCount+"个产品");
            notify();//唤醒消费者
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //消费产品
    public synchronized void consumeProduct() {
        if (productCount > 0){
            System.out.println(Thread.currentThread().getName()+":开始消费第"+productCount+"个产品");
            productCount--;
            notify();//唤醒消费者
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//生产者
class Producer extends Thread{
    private Clerk clerk;
    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }
    @Override
    public void run(){
        System.out.println(getName()+":开始生产产品！");
        while(true){
            try {
                sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduct();
        }
    }
}

//消费者
class Consumer extends Thread{
    private Clerk clerk;
    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }
    @Override
    public void run(){
        System.out.println(getName()+":开始消费产品！");
        while(true){
            try {
                sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumeProduct();
        }
    }
}

运行结果：
在这里插入图片描述

一入猿门深似海
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
Java面试题-面向对象、多线程.pdf
03-17
1、面向对象的特征有哪些方面？ 答：面向对象的特征主要有以下几个方面： ...总共90多道题目，包含面向对象、算法、多线程等面试题及详解 大厂面试题集，纯人工手写，分享不易，有问题敬请谅解 。。。。。。。。
Java网络编程: 面向对象与多线程实战
RaySunWHUT
06-24 750
武汉理工大学(WHUT)“面向对象与多线程综合实验”课程源代码(无GUI最终版(实现client-server网络编程))。
JAVA面向对象-----多线程 7
qq_37453637的博客
06-15 1190
synchronized优化
Java面向对象——多线程
Chen_NC的博客
11-05 306
进程（Program） 是对数据描述与操作的代码的集合。 是程序的一次动态执行过程，它对应了从代码加载。执行至执行完毕的一个完整过程。这个过程也是进程本身产生，发展至消亡的过程。 进程的特点： 进程是系统运行程序的基本单位。 每一个进程都有自己独立的一块内存空间、一组系统资源。 每一个进程的内部数据和状态都是完全独立的。 在操作系统中可以有多个进程，这些进程包括系统进程（由操作系统内部建立的进程）和用户进程（有用户程序建立的进程） 线程 是进程中执行运算的最小单位，可完成一个独立的顺序控制流程
Java面向对象与多线程综合实验（五）之JDBC
有机盐的博客
12-10 3131
本次代码沿用第三次中的User.java Administrator.java Operator.java Browser.java和Doc.java 以及第四次中的LoginWindow.java MenuWindow.java UserWindow.java UpDownloadWindow.java和PasswordWindow.java 按照视频中的操作按照好MySQL和MySQL—Fro...
头歌--Java面向对象 - 常用类
m0_56638814的博客
04-26 8091
头歌--Java面向对象 - 常用类
WHUT-java多线程实验-第一周-继承、多态.zip
01-16
武汉理工大学-Java面向对象与多线程综合实验-(1)封装、继承与多态（IDEA实现）
WHUT-java多线程实验-第四周-GUI.zip
01-16
WHUT-java多线程实验-第四周-GUI（IDEA实现）
WHUT-java多线程实验-第五周-数据库.zip
01-16
WHUT-java多线程实验-第五周-数据库（IDEA实现） 本实验目标在实验 (4) 的基础上实现与本机数据库的连接。即对 DataProcessing 类进行改进，不再使用 Hashtable 存储用户与档案信息，转而使用 JDBC 编程方式实现对...
WHUT-java多线程实验-第三周-文件上传和下载.zip
01-16
WHUT-java多线程实验-第三周-文件上传和下载（IDEA实现）
JAVA基础练习-----实现一个简单的控制台“图书管理系统”
qq_37453637的博客
02-02 3287
核心需求： 1.用户能够登录到系统上。 用户分成两个角色：管理员，普通用户 管理员功能： 1.查阅某个书籍的信息 2.增加书籍 3.删除书籍 4.查看所有书籍列表 5.退出程序 普通用户功能： 1.查阅某个书籍的信息 2.借阅书籍 3.归还书籍 4.退出程序 面向对象的核心之一，结合需求，找到“对象”。从需求中找一些重要的名词：如上述需求中的书，管理员，普通用户，书籍列表；与此同时，一些动词可以理解成“操作”也可以封装成一个类，比如：增加书籍，删除书籍，退出程序。 封装也是面向对象的核心之一，在设计Book
JAVA面向对象-----多线程 6
qq_37453637的博客
06-14 1279
常见锁策略锁的类型悲观锁/乐观锁公平锁/非公平锁可重入锁独占锁/共享锁自旋锁面试题 锁的类型 悲观锁/乐观锁 乐观锁 乐观锁假设认为数据一般情况下不会产生并发冲突，所以在数据进行提交更新的时候，才会正式对数据是否产生并发冲突进行检测，如果发现并发冲突了，则让返回用户错误的信息，让用户决定如何去做。 我们可以这样理解，乐观锁就是用乐观的心态看待线程安全(并发冲突)的问题，直接修改共享变量，基于某些机制，要么直接修改成功(没有冲突)，要么修改失败(通过返回值可以知道，一般是boolean) 。不管成功还是失败,
JAVA-----引用（reference）和对象（object）
qq_37453637的博客
01-26 962
引用类型 1.认识引用（reference）和对象（object） 示例代码1： String str = "Hello World"; int[] arr = { 1, 2, 3, 4, 5 }; 这里的 str 的类型是 String 类型的引用；该引用指向了一个String 类型的对象。 这里的 arr 的类型是 int[] 类型的引用；该引用指向了一个元素类型是 int 的数组类型对象。 2.引用和对象之间的关系 通过引用可以对对象施加影响。我们通常把这个关系称为，该引用指向该对象。 3.引用
JAVA面向对象-----反射机制
qq_37453637的博客
06-17 919
JAVA Reflection 反射机制面试题：Java中创建对象大概有这几种方式？静态语言 / 动态语言什么是反射机制？反射机制的原理反射的优缺点反射的用途类的加载过程什么时候会发生类初始化?类加载器的作用JAVA中基本数据类型的Class是什么？反射机制常用的API反射机制获取类的方法通过反射获取运行时类的完整结构获取Class对象后能做什么?创建类的对象通过反射调用对象的方法通过反射操作属性反射操作泛型反射操作注解 面试题：Java中创建对象大概有这几种方式？ 思考：在讲反射之前，先思考一个问题，ja
JAVA面向对象---继承
qq_37453637的博客
01-20 332
一.基本概念 继承(inheritance)机制： 继承是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。 继承主要解决的问题是：共性的抽取。 例如：鸟和猫都属于动物，那么我们就可以抽取出一些共性的内容。 我们从鸟和猫身体提取出共性：名字这一属性，能够吃东西这一方法，并且将它们提取到动物类中。鸟类和猫类继承了动物类，那么就不需要在这两类当中再定义，姓名属性和吃
JAVA面向对象---多态
qq_37453637的博客
01-22 272
多态 在学习多态之前，我们需要认识这样一个概念：继承是实现多态的一个前提。多态能够帮助我们解决大量的分支语句的情况。 一.基础语法 1.向上转型 一个父类的引用指向了一个子类的对象（看起来好像是把子类的引用转成了父类的引用）。 示例代码1： //Animal.java public class Animal { } //Cat.java public class Cat extends Animal { } //test.java public class Test { public stati
JAVA-----代码中的“异常”
qq_37453637的博客
01-26 239
程序异常 1.初识异常 我们曾经的代码中已经接触了一些 “异常” 了. 例如: 除以 0 System.out.println(10 / 0); 执行结果：Exception in thread “main” java.lang.ArithmeticException: / by zero 数组下标越界 int[] arr = {1, 2, 3}; System.out.println(arr[100]); 执行结果：Exception in thread “main” java.lang.Arr
JAVA面向对象-----类和对象（上）
qq_37453637的博客
02-01 240
类和对象 1.什么是面向对象？ Java是一门纯面相对象的语言(Object Oriented Program，继承OOP)，在面相对象的世界里，一切皆为对象。面相对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。用面相对象的思想来涉及程序，更符合人们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好 面向对象相当于一个编程“范式”，就是要先把业务中的一些概念提取出来，作为“对象”，然后把每个对象的属性和行为都安排好，然后再去组织业务流程。 2.面向对象编程的好处有哪些？ 易维护 采用
武汉理工大学-java面向对象与多线程综合实验csdn
最新发布
12-28
武汉理工大学的Java面向对象与多线程综合实验是一个非常具有挑战性和实用性的实验课程。该课程主要围绕Java编程语言的面向对象特性和多线程编程进行深入实践和探索，在CSND平台上进行讲解和实践。 在这门课程中，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值