第八章：多线程解析以及线程同步，生产者和消费者

最新推荐文章于 2022-03-17 23:53:11 发布
最新推荐文章于 2022-03-17 23:53:11 发布
阅读量276 收藏 1
点赞数
分类专栏： 学习知识回顾与总结 文章标签： 多线程 java 并发编程 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46194472/article/details/108417869
版权

第八章：Thread线程类-------->多线程解析

一：进程和线程

进程：就是一个应用程序，JVM也是一个进程，进程和进程的内存是独立不共享的
线程：线程是一个程序的执行单元，一个进程可以有多个线程；堆内存和方法区是线程共享的内存
	  栈内存是独立的，一个线程一个栈！

二：实现线程的三种方式

（1）第一种方法：继承Thread

  1. 一个类继承了Thread线程类，那么他就是一个线程对象，此时我们直接New这个对象就是创建了一个新的线程，它操作的数据是本类的属性，New几个线程实例就是开启了几个单独的线程
  2. 继承线程类重写run方法，因为我们开启线程** start()后即代表开启成功 ，这句开启代码就结束了。启动成功的线程会自动调用Run方法**，run方法结束代表线程结束
  3. 因为单继承的特性，这种方法会破坏原有的类，所以不常用
 class Thread01 extends Thread{
        int count = 1;
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + 
                "------->"+count++);
            }
        }
    }

//创建线程：三条线程，线程类开启的线程数据不共享
Thread01 t = new Thread01();
     t.start();
     t.start();
     t.start();

//匿名内部类：
new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName() + "------->"+count++);
                }
            }
        }.start();

（2）第二种方法：实现Runnable

  1. 编写一个类继承Runnable接口，重写其run方法
  2. 创建这个对象，将这个对象封装成一个线程对象，Thread t = new Thread(对象)
  3. 创建多个线程，同时操作同一个对象，实现多线程操作同对象
  4. 实现接口的方式还可以继续继承其他类，所以一般情况用这种方式
class runnable01 implements Runnable{
        int count = 1;
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + "------->"+count++);
            }
        }
    }

//需要先实现继承Runnable接口的类，再将其封装为线程，多个线程同时操作一个类，数据共享
//2.第二种：实现Runnable接口
        runnable01 tt = new runnable01();
        new Thread(tt).start();
        new Thread(tt).start();
        new Thread(tt).start();


public class Test09 {
    public static void main(String[] args){
       Runnable r = new Runnable() {
            int count = 100;
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName() + "-------->"+ count--);
                }
            }
        };
       new Thread(r).start();
       new Thread(r).start();
       new Thread(r).start();
    }
}

（3）第三种方法：实现Callable

 和Runnable一样的用法，但是这个实现类有返回值

三：关于线程对象的生命周期

线程的五个状态：
新建状态：刚刚New出来的状态
就绪状态：当前线程具备抢夺CPU时间片（执行权）的权利
运行状态：run方法执行标记着进入运行状态，当时间片结束后，重新进入就绪状态
阻塞状态：当遇到阻塞时间线程会放弃当前时间片（执行权），阻塞解除需要重新进入就绪状态
死亡状态：run方法结束，即线程结束

多线程并发即在就绪状态和运行状态来回调度的结果！！！

生命周期

四：线程的几个常用method的用法

（1）sleep()

  1. 线程的休眠，这个是静态方法，它出现在哪个线程就作用在哪个线程。
  2. 线程的休眠时间的单位是毫秒值
  3. 休眠的作用是让当前线程进入阻塞状态，此线程放弃当前执行权，并在阻塞结束后重新进入就绪状态等待再次被挑选到,但是其不会放弃当前拿到的锁
  4. 可以用作定时器的方法（过时）
  5. Sleep会抛出异常，其作用在run的方法内时，只能try…catch，不能Throws，因为子类不能抛出比父类更多的·异常
  6. 休眠可以被打断，即调用线程.interrupt（）中断方式。这个机制是利用异常的方法打断的

（2）stop（过时）

  1. 这是停止线程的方法，这个方法直接结束当前线程
  2. 这个方法容易造成数据丢失，因为线程直接被杀死了，这是非正常的结束线程的方法
  3. 这个方法已经过时了

（3）正常的线程终止是让run方法结束

 我们正常的操作是：在线程内部定义一个布尔标记，当我们想结束线程时，
 主动将标记赋值为false即可结束run方法，即结束当前线程

在这里插入图片描述

（4）setDaemon（）守护线程

线程分两大类：
一类是：用户线程
一类是：守护线程（后台线程），代表：垃圾回收程序
守护线程的特点：
一般守护线程是死循环，配合定时器起作用，所有用户进程结束，守护线程自动结束

（5）定时器Timer时间类下的schedule()

定时器作用还是特定的时间做特定的事。
三种类型设计定时器：
一：sleep方法设置睡眠时间（不建议使用）
二：定时器类Timer（很少使用），因为有高级框架实现
三：框架

在这里插入图片描述

（6）yieth（）线程礼让

线程的礼让是暂停当前线程对象，并执行其他线程
它是对其他线程的让位，并是当前线程重新回到就绪状态

（7）setPriority（）设置优先级

优先级的设置：是将当前的线程修改其优先级，只是让其执行的概念更高而已
最高级别：Thread.MAX_PRIORITY = 10
默认优先级：Thread.NORM_PRIORITY = 5；
最低优先级：Thread.MIN_PRIORITY =1；

五：多线程的同步（重点）

（1）什么时候并发会存在安全问题

三个条件：
		条件一：多线程并发下
		条件二：有共享数据
		条件三：共享数据有修改的行为

（2）怎么解决线程安全问题

使用“线程同步机制”解决线程安全问题
在多线程并发环境下有共享数据需要被修改，那么就会出现线程安全问题，此时我们考虑让线程
排队，即不能实现并发。虽然会丢失一些效率，但是安全是第一考虑要素
  1. 异步编程模型
异步编程其实就是多线程并发，各自执行各自的，这种编程模型效率1高，但是容易出现安全问题
  1. 同步编程模型
在有一个线程在执行时，其他线程必须等待这个线程执行结束释放锁才能执行，
这种设计模型效率低，线程需要等待，但是，数据安全

（3）实现同步的方式：加同步锁（synchronized）

synchronized写法有三种：
第一种：同步代码块
第二种：同步方法（实例方法上）
第三种：静态方法上使用

1. 同步代码块

 Runnable t =new Runnable(){
            int tickets =100;
            @Override
            public void run() {
                while (true){
                    synchronized (this) {
                        if (tickets > 0) {
                            try {
                                System.out.println(
                                Thread.currentThread().getName() +
                                 "----窗口卖出第" + tickets-- +"张！");
                                Thread.sleep(100);//一个线程卖出一张票就休眠，释放当前锁
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }else
                            break;
                    }
                }
            }
        };
        //3个线程
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
  1. 同步代码块中的锁可以是任意的对象，只要是所有线程共享的对象就能充当锁
  2. 当有线程拿到锁后，进入代码块中，其他线程过来寻找锁没找到会释放执行权然后在锁池中等待寻找锁。
  3. 当释放锁后，线程进入就绪阶段继续抢夺执行权

2. 同步方法（实例方法）

 class synchronized window {
        private int tickets =100;
        @Override
        public void run() {
            while (tickets >0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                   e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "----窗口卖出第" + tickets-- +"张！");
           }
        }
    }
  1. synchronized出现在实例方法上，后面无需手动添加锁，它的锁就是this，
  2. 放在方法体上时，表示整个方法体都需要同步，这样扩大了同步范围，导致程序执行效率降低。不常用

3.静态方法上的synchronized

表示找类锁，这种锁永远只有一个，每个调用静态方法的线程对象都需要拿到这个锁才会运行

4.开发中怎么解决线程安全问题

java中三大变量
1.实例变量：堆中
2.静态变量：方法区中
3.局部变量：栈中
局部变量永远不存在线程安全问题，因为是栈内存，一个栈一个局部变量，不会出现变量修改问题

静态变量和实例变量是线程共享的区域，所以会涉及线程安全问题
  1. synchronized会使程序的执行效率变低，降低用户体验。最好用其他解决方案
  2. 第一种方案：尽量使用局部变量代替“实例变量和静态变量”
  3. 第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了
  4. 第三种：如果不能使用第一第二中才使用synchronize线程同步机制解决

六：生产者与消费者模式

什么是生产者消费者模式
	1.生产者负责生产，消费者负责消费
	2.生产者和消费者线程要求达到均衡
	3.这是一种特殊的业务需求，这种情况需要使用wait和notify

（1）Object下的wait方法和notify方法

1.wait和notify是java对象的方法
2.wait和notify是建立在线程同步的基础上的
3.wait作用：o.wait()让正在o对象上活动的线程t进入到等待阶段，
			并且释放t线程之前占用的o对象的锁
4.notify作用：o.notify()让正在o对象上等待的线程唤醒，
			只是唤醒，不会释放o对象上占有的锁的线程

（2）生产者与消费者代码实现

①：传统wait（）、notify（）

//生产线程
class Producer1 extends Thread {
    //1.1) 定义共享数据，储存数据的集合
    private Stack stack;

    public Producer1(Stack stack) {
        this.stack = stack;
    }

    @Override
    public void run() {
        Random r = new Random();
        while (true) {
            synchronized (stack) {
                if (stack.size() > 0) {
                    try {
                        stack.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
                    int i = r.nextInt(10);
                    stack.push(i);
                    System.out.println(Thread.currentThread().getName() + "-------->" + i);
                    stack.notify();
            }
        }
    }
}

//消费线程
class Consumer1 extends Thread {
    //1.1) 定义共享数据，储存数据的集合
    private Stack stack;

    public Consumer1(Stack stack) {
        this.stack = stack;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (stack) {
                if (stack.size() == 0) {
                    try {
                        stack.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
                Object pop = stack.pop();
                System.out.println(Thread.currentThread().getName() + "-------->" + pop);
                stack.notify();
            }
        }
    }
}

public class Test02 {
    public static void main(String[] args) {
        //1.1) 创建仓库
        Stack<Integer> stack = new Stack<>();

        //1.2) 创建线程对象
        Producer1 producer1 = new Producer1(stack);
        Consumer1 consumer1 = new Consumer1(stack);

        //1.3) 给线程改名
        producer1.setName("生产者");
        consumer1.setName("消费者");

        //1.4） 启动线程
        producer1.start();
        consumer1.start();

    }
}

②：sleep

//1.生产者
class Producer extends Thread{
    //1.1) 定义共享数据，即仓库
    private Stack stack;

    //1.2) 创建线程将对象传递过来
    public Producer(Stack stack) {
        this.stack = stack;
    }

    //1.3）重写run方法，线程启动其实就是运行这个方法
    @Override
    public void run() {
        //1.4) 定义随机数类
        Random r = new Random();
        //1.5) 循环，无限循环启动模拟生产者行为
        while (true){
            //1.6) 如果栈集合中的元素少于50个，那么就一直生产
            if (stack.size() < 1000){
                //1.7) 生产一个随机数产品
                int i = r.nextInt(100);
//                try {
//                    sleep(100);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                //1.8) 压入栈集合顶部
                stack.push(i);
                //1.9） 打印生产信息：
                System.out.println(Thread.currentThread().getName() + "------->"+ i);
            }else {
            //1.9) 当集合中有100个产品后，此生产者线程进入休眠状态，进入阻塞状态，释放执行权
            try {           // 只能try...catch因为子类不能抛出比父类更多的异常
                Thread.sleep(1000*5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        }

    }
}

//2.消费者
class Consumer extends Thread{
    //2.1) 定义共享数据，即仓库
    private Stack stack;

    //2.2) 创建线程将对象传递过来
    public Consumer(Stack stack) {
        this.stack = stack;
    }

    //2.3）重写run方法，线程启动其实就是运行这个方法
    @Override
    public void run() {
        //2.5) 循环，无限循环启动模拟消费者行为
        while (true) {
            //2.6) 如果栈集合中的元素大于0个，那么就一直消费
            if (stack.size() > 0) {
                //2.7) 弹出栈集合顶部元素
//                try {
//                    sleep(200);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                Object pop = stack.pop();
                System.out.println(Thread.currentThread().getName() + "----->" + pop );
            } else {
                //2.8) 当集合中没有产品后，此生产者线程进入休眠状态，进入阻塞状态，释放执行权
                try {           // 只能try...catch因为子类不能抛出比父类更多的异常
                    Thread.sleep(1000 * 5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

public class Test01 {
    public static void main(String[] args) {
        //1.1) 创建仓库
        Stack<Integer> stack = new Stack<>();

        //1.2) 创建线程对象
        Producer producer = new Producer(stack);
        Consumer consumer = new Consumer(stack);

        //1.3) 给线程改名
        producer.setName("生产者");
        consumer.setName("消费者");

        //1.4） 启动线程
        producer.start();
        consumer.start();

    }
}
进击的小小码农
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程--同步互斥&生产者消费者（一）
ROGEN1-秀发
09-21 910
一、线程同步&互斥 在实际应用中，多个线程往往会共享一些数据，并且各个线程之间的状态和行为是相互影响的。线程之间的影响有两种，一种是线程间的互斥，另一种是线程间的同步。 ---线程安全（Thread-Safe） ---线程间的互斥 ---线程间的同步 线程之间的关系大致可以分为两类 1、线程之间通过对资源的竞争，包括共享的数据和硬件资源，所产生的相互制约关系，这类线程间的主要问
并行计算导论（原书第2版）.[美]Ananth Grama(带详细书签).pdf
04-24
3.6.5 流水线模型或生产者-消费者模型 3.6.6 混合模型 3.7 书目评注 习题 第4章 基本通信操作 4.1 一对多广播以及多对一归约 4.1.1 环或线性阵列 4.1.2 格网 4.1.3 超立方体 4.1.4 平衡二叉树 4.1.5 算法...
java多线程实现生产者和消费者
12-22
java多线程实现生产者和消费者 ，4种实现方式，分别为synchronizated，condition和lock，信号量，阻塞队列
java基础之线程同步实例之Producer与Consumer
有目标才会更充实
03-29 2533
class Producer implements Runnable{ Message ms =new Message(); int i = 0; Producer(Message ms){  this.ms = ms; } public void run(){  while(true){   if(i > 10){    break;   }else{     System.out.println("Producer set :"+i);    ms.setMessage(i);    i++;   } 
生产者消费者模式--java多线程同步方法的应用
朱同学的博客
03-06 296
生产者消费者模式是对java多线程的一个基础应用 我们一共设计了货物 生产者 消费者三个类 货物有商标和名称两个属性和对应的设置访问方法 生产者用于设置货物的属性 消费者用于访问并打印货物的属性 我们设置了一个生产者线程和两个消费者线程,其中生产者一次只能生产一批货物,由两个消费者争夺资源,代码如下 class Goods { private String brand; private Str...
python 多线程生产者消费者代码
weixin_33769207的博客
02-17 164
import time import threading #当还剩下一百个产品时，则不进行消费，待生产者生产 #当生产了一千个产品时，则不进行生产，待消费者消费 product = 0 #产品初始化时为0 lock = threading.Condition() class Producer(threading.Thread): def __init__(...
汪文君高并发编程实战视频资源全集
08-08
│ 高并发编程第一阶段26讲、多线程下的生产者消费者模型，以及详细介绍notifyAll方法.mp4 │ 高并发编程第一阶段27讲、wait和sleep的本质区别是什么，深入分析（面试常见问题）.mp4 │ 高并发编程第一阶段28讲、...
汪文君高并发编程实战视频资源下载.txt
08-08
│ 高并发编程第一阶段26讲、多线程下的生产者消费者模型，以及详细介绍notifyAll方法.mp4 │ 高并发编程第一阶段27讲、wait和sleep的本质区别是什么，深入分析（面试常见问题）.mp4 │ 高并发编程第一阶段28讲、...
python入门到高级全栈工程师培训 第3期 附课件代码
06-07
第8章 01 上节课复习 02 软件包介绍 03 rpm软件包管理 04 yum软件包管理 05 源码安装python3.5 06 ssh服务 07 apache服务 08 samba服务 第9章 01 Python开发系列课程概要 02 Python作业要求以及博客 03 编程语言...
java并发编程
01-03
[免费观看][免费观看] 00:27:48分钟 | 第2节理解多线程与并发的之间的联系与区别 [免费观看] 00:11:59分钟 | 第3节解析多线程与多进程的联系以及上下文切换所导致资源浪费问题 [免费观看] 00:13:03分钟 | 第4节学习...
多个生产者和消费者线程
x321906241的博客
07-30 157
/** * 作者：kuma * 版本：v1.0 * */ public class study_12_5 { public static void main(String[] args) { //线程间通信，生产者消费者 Resource r=new Resource(); Producer pro=new Producer(r); Consumer con=new Consumer(r); Thread
多线程程序设计学习（6）Producer-Consumer模式
weixin_33736649的博客
07-19 113
Producer-Consumer【生产消费者模式】一:Producer-Consumer pattern的参与者--->产品（蛋糕）--->通道（传递蛋糕的桌子）--->生产者线程（制造蛋糕的线程）--->消费者线程（吃掉蛋糕的线程） 二：Producer-Consumer pattern模式什么时候使用---&gt...
使用线程同步处理实现生产者与消费者的基本程序模型
drop_it的博客
03-17 408
关于线程同步死锁及设计模式的应用。
线程的同步问题--生产者 消费者
star_fighting的博客
02-14 2332
生产者消费者模型描述： 生产者/消费者问题可以描述为：两个或者更多的进程（线程）共享同一个缓冲区，其中一个或多个进程（线程）作为“生产者”会不断地向缓冲区中添加数据，另一个或者多个进程（线程）作为“消费者”从缓冲区中取走数据。生产者/消费者模型关注的是以下几点： 生产者和消费者必须互斥的使用缓冲区 缓冲区空时，消费者不能读取数据 缓冲区满时，生产者不能添加数据 生产者/消费者模型的优点在...
Java线程间同步实现生产者-消费者模式
技术收藏
11-09 864
 　　1.生产者-消费者模式实现概述　　生产者与消费者模式是我们在编程过程中经常会遇到的，就像我们生活那样，生产者生产出产品，消费者去购买产品。在这里我们创建三个线程，一个主控线程main，用于创建各辅助线程；一个生产者线程，用于生产产品；一个消费者线程，用于购买产品。另外，我们创建一个队列类Queue，生产线程生产的产品将放置到该队列中，然后消费者线程在该队列中取走产品。　　2.实现该模式的要点
JAVA多线程设计模式篇 6、Producer-Consumer 模式——你生产我消费
EndlessProcess的专栏
03-17 2657
Producer-Consumer模式可以看作模式的模式，即许多模式可以看作该模式的一个实例，
线程通信——生产者与消费者（Java）
码小兔的博客
08-27 608
目录1、应用场景：生产者和消费者问题1.1 Java提供了3个方法解决线程之间的通信问题2、实战消费者与生产者2.1 准备阶段2.1.1 Product类2.1.2 Test类2.2 使用同步代码块来实现线程通信2.2.1 ProduceRunnable类2.2.2 ConsumerRunnable类2.3 运行结果2.4 使用同步方法来实现线程通信2.4.1 Product类2.4.2 ProduceRunnable类2.4.3 ConsumerRunnable类2.4.4 Test类2.5 使用Lock
java 多线程同步/ 消费者生产者问题.
weixin_30650859的博客
08-21 118
多线程下要注意的地方: 1. this.wait()和this.notify()要成对使用; 2. 对于sychronized要慎重. 上锁/不上锁要谨慎考虑. 用了可能会在效率上下降, 不用可能导致不可预测的结果值. 3. wait 和 thread.sleep()有很大差别: wait是object类中的方法, 而sleep是thread下的方法. wait表示指的是当前的线程进行wai...
java实现线程同步一个生产者和一个消费者
crazychen的专栏
03-04 744
package test; import java.util.Scanner; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Test{ static Scanner sc = new Scanner(System.in); static
线程同步之生产者和消费者
最新发布
04-27
线程同步中的生产者和消费者问题是一种经典的多线程并发问题。其基本思想是：生产者生产产品并将其放置在缓冲区中，消费者则从缓冲区中取走产品进行消费。生产者和消费者通过共享缓冲区来进行通信。为了保证线程安全...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值