多线程,了解-概念-实现方式-常见方法-安全问题-死锁-生产者消费者

已于 2023-03-22 20:00:42 修改
阅读量467 收藏
点赞数
文章标签： java 开发语言
于 2022-11-30 01:40:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46589095/article/details/128106157
版权

了解

简单了解多线程

是指从软件或者硬件上实现多个线程并发执行的技术。 具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程，提升性能。

简单了解多线程

                                               

 简单了解多线程

                                                  

 简单了解多线程

                                                  

 简单了解多线程

                                                  

概念

 线程相关的概念

                 并行：在同一时刻，有多个指令在多个CPU上同时执行。

                 并发：在同一时刻，有多个指令在单个CPU上交替执行。

并发和并行

                  并行：在同一时刻，有多个指令在多个CPU上同时执行。

 

 并发和并行

                 并发：在同一时刻，有多个指令在单个CPU上交替执行。

  并发和并行

                  并发：在同一时刻，有多个指令在单个CPU上交替执行。

 

 并发和并行

                  并发：在同一时刻，有多个指令在单个CPU上交替执行。

 

进程和线程

      进程：是正在运行的软件        

独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位。

动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的。

并发性：任何进程都可以同其他进程一起并发执行

 进程和线程

 线程：是进程中的单个顺序控制流，是一条执行路径。

                                            

                                           

                     

                     

                                          

                                           

  

进程和线程

      线程：是进程中的单个顺序控制流，是一条执行路径。  

单线程：一个进程如果只有一条执行路径，则称为单线程程序

多线程：一个进程如果有多条执行路径，则称为多线程程序

 小结

      并发和并行

并行：在同一时刻，有多个指令在多个CPU上同时执行。

并发：在同一时刻，有多个指令在单个CPU上交替执行。

       进程和线程

进程：就是操作系统中正在运行的一个应用程序。

线程：就是应用程序中做的事情。比如：360软件中的杀毒，扫描木马，清理垃圾。

实现方式

多线程的实现方式

多线程的实现方案

继承Thread类的方式进行实现

实现Runnable接口的方式进行实现

利用Callable和Future接口方式实现

package com.itheima.threaddemo1;

public class MyThread extends Thread{
    @Override
    public void run() {
        //代码就是线程在开启之后执行的代码
        for (int i = 0; i < 100; i++) {
            System.out.println("线程开启了" + i);
        }
    }
}

package com.itheima.threaddemo1;

public class Demo {
    public static void main(String[] args) {
        //创建一个线程对象
        MyThread t1 = new MyThread();
        //创建一个线程对象
        MyThread t2 = new MyThread();

        //t1.run();//表示的仅仅是创建对象,用对象去调用方法,并没有开启线程.
        //t2.run();
        //开启一条线程
        t1.start();
        //开启第二条线程
        t2.start();
    }
}
线程开启了90
线程开启了99
线程开启了91
线程开启了92
线程开启了93
线程开启了94
线程开启了95
线程开启了96
线程开启了97
线程开启了98
线程开启了99

Process finished with exit code 0

 

方案1：继承Thread类

定义一个类MyThread继承Thread类

在MyThread类中重写run()方法

创建MyThread类的对象

启动线程(如上)

两个小问题：

为什么要重写run()方法？

         因为run()是用来封装被线程执行的代码

run()方法和start()方法的区别？

         run()：封装线程执行的代码，直接调用，相当于普通方法的调用，并没有开启线程。          start()：启动线程；然后由JVM调用此线程的run()方法

多线程的实现方式

方式2：实现Runnable接口

定义一个类MyRunnable实现Runnable接口

在MyRunnable类中重写run()方法

创建MyRunnable类的对象

创建Thread类的对象，把MyRunnable对象作为构造方法的参数 启动线程

package com.itheima.threaddemo2;

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //线程启动后执行的代码
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "第二种方式实现多线程" + i);
        }
    }
}

 测试类:

package com.itheima.threaddemo2;

public class Demo {
    public static void main(String[] args) {
        //创建了一个参数的对象
        MyRunnable mr = new MyRunnable();
        //创建了一个线程对象,并把参数传递给这个线程.
        //在线程启动之后,执行的就是参数里面的run方法
        Thread t1 = new Thread(mr);
        //开启线程
        t1.start();


        MyRunnable mr2 = new MyRunnable();
        Thread t2 = new Thread(mr2);
        t2.start();

    }
}
Thread-0第二种方式实现多线程96
Thread-1第二种方式实现多线程96
Thread-0第二种方式实现多线程97
Thread-1第二种方式实现多线程97
Thread-0第二种方式实现多线程98
Thread-1第二种方式实现多线程98
Thread-0第二种方式实现多线程99
Thread-1第二种方式实现多线程99

Process finished with exit code 0

方式3：Callable和Future

定义一个类MyCallable实现Callable接口

在MyCallable类中重写call()方法 创建MyCallable类的对象

创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数

创建Thread类的对象，把FutureTask对象作为构造方法的参数

启动线程

再调用get方法，就可以获取线程结束之后的结果。

package com.itheima.threaddemo3;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("跟女孩表白" + i);
        }
        //返回值就表示线程运行完毕之后的结果
        return "答应";
    }
}

 测试类:

package com.itheima.threaddemo3;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //线程开启之后需要执行里面的call方法
        MyCallable mc = new MyCallable();

        //Thread t1 = new Thread(mc);

        //可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
        FutureTask<String> ft = new FutureTask<>(mc);

        //创建线程对象
        Thread t1 = new Thread(ft);

        String s = ft.get();
        //开启线程
        t1.start();

        //String s = ft.get();
        System.out.println(s);
    }
}

 正确的代码:

  public static void main(String[] args) throws ExecutionException, InterruptedException {

        //String s = ft.get();
        //开启线程
        t1.start();

        String s = ft.get();
        System.out.println(s);
    }

 三种方式的对比

优点

缺点

实现Runnable、

Callable接口

扩展性强，实现该接口的同时还可以继承其他的类。

编程相对复杂，不能直接使用Thread类中的方法

继承Thread类

编程比较简单，可以直接使用Thread类中的方法

可以扩展性较差，

不能再继承其他的类

常见方法

线程类的常见方法

获取和设置线程名称

获取线程的名字

  • String getName​()：返回此线程的名称

Thread类中设置线程的名字

  • void setName​(String name)：将此线程的名称更改为等于参数 name
  • 通过构造方法也可以设置线程名称
package com.itheima.threaddemo4;

public class MyThread extends Thread {

    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

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

 测试类:

package com.itheima.threaddemo4;

public class Demo {
    //1,线程是有默认名字的,格式:Thread-编号
    public static void main(String[] args) {
        MyThread t1 = new MyThread("小蔡");
        MyThread t2 = new MyThread("小强");

        //t1.setName("小蔡");
        //t2.setName("小强");

        t1.start();
        t2.start();
    }
}

小强@@@97
小蔡@@@98
小强@@@98
小蔡@@@99
小强@@@99

Process finished with exit code 0

获得当前线程的对象

  • public static Thread currentThread()：返回对当前正在执行的线程对象的引用
package com.itheima.threaddemo5;

public class Demo {
    public static void main(String[] args) {
        String name = Thread.currentThread().getName();
        System.out.println(name);
    }
}

线程休眠

  • public static void sleep(long time)：让线程休眠指定的时间，单位为毫秒。
package com.itheima.threaddemo6;

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
    }
}

测试类:(获取线程,休眠,获取名称)

package com.itheima.threaddemo6;

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        /*System.out.println("睡觉前");
        Thread.sleep(3000);
        System.out.println("睡醒了");*/

        MyRunnable mr = new MyRunnable();

        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);

        t1.start();
        t2.start();
    }
}

Thread-0---97
Thread-1---98
Thread-0---98
Thread-0---99
Thread-1---99

Process finished with exit code 0

线程调度

多线程的并发运行：    

计算机中的CPU，在任意时刻只能执行一条机器指令。每个线程只有获得CPU的使用权才能执行代码。      

 各个线程轮流获得CPU的使用权，分别执行各自的任务。

线程有两种调度模型

  • 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
  • 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程      

        获取的 CPU 时间片相对多一些

 Java使用的是抢占式调度模型

                                CPU

 线程的优先级

        public final void setPriority(int newPriority)    设置线程的优先级

        public final int getPriority()                              获取线程的优先级

package com.itheima.threaddemo7;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
        return "线程执行完毕了";
    }
}

import java.util.concurrent.FutureTask;

public class Demo {
    public static void main(String[] args) {
        //优先级: 1 - 10 默认值:5
        MyCallable mc = new MyCallable();
        FutureTask<String> ft = new FutureTask<>(mc);
        Thread t1 = new Thread(ft);
        t1.setName("飞机");
        t1.setPriority(10);
        //System.out.println(t1.getPriority());//5
        t1.start();

        
        MyCallable mc2 = new MyCallable();
        FutureTask<String> ft2 = new FutureTask<>(mc2);
        Thread t2 = new Thread(ft2);
        t2.setName("坦克");
        t2.setPriority(1);
        //System.out.println(t2.getPriority());//5
        t2.start();
    }
}

 后台线程/守护线程

public final void setDaemon(boolean on)：设置为守护线程

package com.itheima.threaddemo8;

public class MyThread1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName() + "---" + i);
        }
    }
}

package com.itheima.threaddemo8;

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

package com.itheima.threaddemo8;

public class Demo {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();

        t1.setName("女神");
        t2.setName("备胎");

        //把第二个线程设置为守护线程
        //当普通线程执行完之后,那么守护线程也没有继续运行下去的必要了.
        t2.setDaemon(true);

        t1.start();
        t2.start();
    }
}
女神---8
备胎---8
女神---9
备胎---9
备胎---10
备胎---11
备胎---12
备胎---13
Process finished with exit code 0

为什么多线程会发生线程安全问题?

 多线程安全问题：就是存在多条线程操作同一条数据，而CPU执行时先将主内存中的数据拷贝一份做缓存，之后的操作不在请求主内存中拿数据而是从缓存中获取数据，如果执行完后有更改再同步回主内存，而导致了最终结果的错误，而单线程情况下则完全不会出现这一情况

 线程生命周期

安全问题

线程的安全问题

 需求：某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票

思路：

①定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100;

② 在Ticket类中重写run()方法实现卖票，代码步骤如下

      A：判断票数大于0，就卖票，并告知是哪个窗口卖的

      B：票数要减1

      C：卖光之后，线程停止

③ 定义一个测试类TicketDemo，里面有main方法，代码步骤如下

    A：创建Ticket类的对象

    B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称

    C：启动线程

package com.itheima.threaddemo9;

public class Ticket implements Runnable {
    //票的数量
    private int ticket = 100;
    private Object obj = new Object();

    @Override
    public void run() {
        while(true){
            synchronized (obj){//多个线程必须使用同一把锁.
                if(ticket <= 0){
                    //卖完了
                    break;
                }else{
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticket--;
                    System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
                }
            }
        }
    }
}

package com.itheima.threaddemo9;

public class Demo {
    public static void main(String[] args) {
        /*Ticket ticket1 = new Ticket();
        Ticket ticket2 = new Ticket();
        Ticket ticket3 = new Ticket();

        Thread t1 = new Thread(ticket1);
        Thread t2 = new Thread(ticket2);
        Thread t3 = new Thread(ticket3);*/

        Ticket ticket = new Ticket();

        Thread t1 = new Thread(ticket);
        Thread t2 = new Thread(ticket);
        Thread t3 = new Thread(ticket);

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

        t1.start();
        t2.start();
        t3.start();
    }
}

 改造:

    @Override
    public void run() {
        while (true) {
            // 当前这个this表示的是Ticket的票对象,我们在测试类中创建了几个票对象?
            // 答: 1个,所以能保证多个线程使用的是同一个锁对象
            synchronized (this){
                if (ticket <= 0) {
                    //卖完了
                    break;
                } else {
                    System.out.println(Thread.currentThread().getName() + "正在卖" + ticket + "号票");
                    ticket--;
                }
            }
        }
    }

卖票案例的思考

刚才讲解了电影院卖票程序，好像没有什么问题。但是在实际生活中，售票时出票也是需要时间的， 所以，在出售一张票的时候，需要一点时间的延迟，接下来我们去修改卖票程序中卖票的动作： 每次出票时间100毫秒，用sleep()方法实现

卖票出现了问题

        相同的票出现了多次

        出现了负数的票

问题原因： 

线程执行的随机性导致的

卖票案例数据安全问题的解决

卖票案例数据安全问题的解决

为什么出现问题?(这也是我们判断多线程程序是否会有数据安全问题的标准)

        多线程操作共享数据

如何解决多线程安全问题呢?

        基本思想：让程序没有安全问题的环境

怎么实现呢?

         把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可

         Java提供了同步代码块的方式来解决

                                                                            

                                                                  

 

同步代码块

锁多条语句操作共享数据，可以使用[同步代码块]实现 

格式：        

synchronized(任意对象) {              

  多条语句操作共享数据的代码

 } 

使用 Runnable就可以了

 默认情况是打开的，只要有一个线程进去执行代码了，锁就会关闭  

 当线程执行完出来了，锁才会自动打开

同步的好处和弊端 

好处：解决了多线程的数据安全问题

弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率   

同步方法 

同步方法：就是把synchronized关键字加到方法上

格式：

       修饰符 synchronized 返回值类型 方法名(方法参数) {    }

同步代码块和同步方法的区别:

同步代码块可以锁住指定代码,同步方法是锁住方法中所有代码

同步代码块可以指定锁对象,同步方法不能指定锁对象 

同步方法的锁对象是什么呢?

this 

package com.itheima.threaddemo011;
/*
    任务类,将来只会创建一个任务类对象,可以由多个线程,共同执行这个任务对象
 */
public class MyRunnable implements Runnable {
    private static int ticketCount = 100;

    @Override
    public void run() {
        // 希望通过这个run方法,获知当前是哪个线程正在执行任务,从而决定以什么方式保证数据安全;
        while(true){
            if("窗口一".equals(Thread.currentThread().getName())){
                //同步方法
                boolean result = synchronizedMthod();
                if(result){
                    break;
                }
            }

            if("窗口二".equals(Thread.currentThread().getName())){
                //同步代码块
                synchronized (MyRunnable.class){
                    if(ticketCount == 0){
                       break;
                    }else{
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        ticketCount--;
                        System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
                    }
                }
            }

        }
    }

    private static synchronized boolean synchronizedMthod() {
        if(ticketCount == 0){
            return true;
        }else{
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ticketCount--;
            System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
            return false;
        }
    }
}

同步方法

同步静态(static)方法：就是把synchronized关键字加到静态方法上

格式：

  修饰符 static synchronized 返回值类型 方法名(方法参数) {    }

同步静态方法的锁对象是什么呢?

类名.class

package com.itheima.day013_Teacher.demo02_MaiPiao;
/*
    这个类当成任务类
 */
public class Piao implements Runnable {

    // 票的总数
     private  int p=100;
    @Override
    public void run() {
       while (true){
           synchronized (this){
               if(p>0){
                   // 卖票的行为
                   System.out.println(Thread.currentThread().getName()+"卖了:"+p-- +"号票");
               }else {
                   System.out.println(Thread.currentThread().getName()+"卖票结束...");
                   break;
               }
           }
       }
    }
    /*@Override
    public void run() {
        while (true){
            // 人为规定,返回true表示可以继续卖票,返回false,表示票卖完了
           boolean r =  maiPiao();
           if(!r){
               break;
           }
        }
    }*/

    private synchronized boolean maiPiao() {
        if(p>0){
            // 卖票的行为
            System.out.println(Thread.currentThread().getName()+"卖了:"+p-- +"号票------------");
            return true;
        }else {
            System.out.println(Thread.currentThread().getName()+"卖票结束...");
            return false;
        }
    }
}

Lock锁

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁， 为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock

Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作

Lock中提供了获得锁和释放锁的方法

 void lock()：获得锁

void unlock()：释放锁

 Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化

ReentrantLock的构造方法

ReentrantLock​()：创建一个ReentrantLock的实例

package com.itheima.threaddemo012;

import java.util.concurrent.locks.ReentrantLock;

public class Ticket implements Runnable {
    //票的数量
    private int ticket = 100;
    private Object obj = new Object();
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            //synchronized (obj){//多个线程必须使用同一把锁.
            try {
                lock.lock();//获得锁
                if (ticket <= 0) {
                    //卖完了
                    break;
                } else {
                    Thread.sleep(100);
                    ticket--;
                    System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();//释放锁
            }
            // }
        }
    }
}

死锁

死锁

线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行。

 

 

 

 生产者消费者

生产者消费者模式概述

生产者消费者理想情况 

 

生产者等待 

package com.itheima.day013_Teacher.demo04_tongXin;
/*
    桌子类,会包含我们的共享数据
 */
public class ZhuoZi {
    private String bz;// 包子是否存在
    private int count;// 表示已经吃了多少个包子

    // 生成包子的方法
    public void shengChan(){
        synchronized (this){
            if(count==9){
                System.out.println("生产够了...");
                Thread.currentThread().stop();
            }
            if(bz!=null){
                // 有包子,等待
                try {
                    this.wait();// 将来被别的线程叫醒之后,代码会从这里继续往下走!
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 做包子
            bz = "猪肉馅的包子";
            System.out.println("厨师做了一个:"+bz);
            this.notifyAll();// 叫醒对方

        }
    }

    // 吃包子的方法
    public void chiBaoZi(){
        synchronized (this){
            if(count>=10){
                System.out.println("吃饱了...");
                Thread.currentThread().stop();
                ///System.exit(0);
            }
            if(bz ==null){
                // 说明没有包子,等一会
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 代码走到这里的时候,说明一定是有包子,开吃
            count++;
            System.out.println("吃货吃了:"+bz+",当前是第"+count+"个包子");
            bz=null;
            this.notifyAll();

        }
    }
}

package com.itheima.day013_Teacher.demo04_tongXin;

public class ChiHuo implements Runnable{
    // 通过构造方法传递想要使用的数据
    public ChiHuo(ZhuoZi z) {
        this.z = z;
    }
    private ZhuoZi z ;

package com.itheima.day013_Teacher.demo04_tongXin;

public class ChuShi implements Runnable{
    private ZhuoZi z;

    public ChuShi(ZhuoZi z) {
        this.z = z;
    }

    @Override
    public void run() {
        while (true){
            z.shengChan();
        }
    }
}

package com.itheima.day013_Teacher.demo04_tongXin;

public class Entry {
    public static void main(String[] args) {
        ZhuoZi z = new ZhuoZi();
        ChiHuo ch = new ChiHuo(z);
        ChuShi cs = new ChuShi(z);
        //创建线程,给厨师和吃货绑定任务
        new Thread(ch).start();
        new Thread(cs).start();

    }
}

厨师做了一个:猪肉馅的包子
吃货吃了:猪肉馅的包子,当前是第1个包子
厨师做了一个:猪肉馅的包子
吃货吃了:猪肉馅的包子,当前是第2个包子
厨师做了一个:猪肉馅的包子
吃货吃了:猪肉馅的包子,当前是第3个包子
厨师做了一个:猪肉馅的包子
吃货吃了:猪肉馅的包子,当前是第4个包子
厨师做了一个:猪肉馅的包子
吃货吃了:猪肉馅的包子,当前是第5个包子
厨师做了一个:猪肉馅的包子
吃货吃了:猪肉馅的包子,当前是第6个包子
厨师做了一个:猪肉馅的包子
吃

 等待和唤醒的方法

为了体现生产和消费过程中的等待和唤醒，Java就提供了几个方法供我们使用，这几个方法在Object类中 Object类的等待和唤醒方法：

方法名

说明

void wait​()

导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法

void notify​()

唤醒正在等待对象监视器的单个线程

void notifyAll​()

唤醒正在等待对象监视器的所有线程 

 阻塞队列实现等待唤醒机制

阻塞队列继承结构

 

 阻塞队列实现等待唤醒机制

BlockingQueue的核心方法：     

                put(anObject):将参数放入队列，如果放不进去会阻塞。     
                take():取出第一个数据，取不到会阻塞。

常见BlockingQueue：     

          ArrayBlockingQueue：底层是数组，有界。     

          LinkedBlockingQueue：底层是链表，无界。但不是真正的无界，最大为int的最大值。

 

程序员～小鱼儿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ 多线程通信方式简介并结合生产者-消费者模式代码实现
10-15
本文将深入探讨C++中的多线程通信方式，并结合经典的生产者-消费者模式来阐述其实现。 一、C++多线程基础 C++11引入了标准库`<thread>`，提供了对多线程的支持。创建线程的基本方法是通过`std::thread`类，如下所示...
用多线程同步方法解决生产者－消费者问题
03-07
总的来说，解决生产者-消费者问题需要深入理解线程同步原理，并结合具体的需求进行设计和实现。这个过程不仅锻炼了编程能力，也对并发编程的理解有着重要的实践意义。在实际项目中，这样的并发控制技术广泛应用在...
【并发编程】多线程安全问题，如何避免死锁
阿Q的小窝
06-26 2147
本文我们从大家熟知的线程和进程入手，通过对比他俩的使用场景、代码使用来方便记忆。随后对线程的创建方式以及生命周期进行了详细的讲解。然后介绍了线程使用过程中的一些方法，方便大家更好的入手。最后对多线程的安全问题和死锁问题进行了总结.
操作系统作业
qq_59572329的博客
02-21 2050
I．整数除以零 II． sin（）函数调用 III． read 系统调用。，且都按输入、计算和输出的顺序执行，则执行完3个作业需要的时间最少是 （）。D．用户级线程可以在不支持内核级线程的操作系统上实现。执行的作业，每个作业的输入、计算和输出时间均分别为。C．用户级线程间的切换比内核级线程间的切换效率高。3、某单CPU系统中有输入和输出设备各1台，现有。B．操作系统为每个用户级线程建立一个线程控制块。A．内核级线程的调度由操作系统完成。的叙述中，正确的是____。Ⅰ．具有并发和并行的特点。
多线程入门（新手必看）
m0_73613534的博客
04-20 161
本文由浅入讲诉了多线程的相关概念以及应用，帮助新入坑的小伙伴快速入门多线程
C++ 实现多线程的生产者(producer) - 消费者(consumer) 模型
comedate的专栏
01-27 2613
本文介绍了生产者消费者的并发编程模型，并用详细的 C++ 代码实现了一个简单的生产者消费者的实例；
生产者-消费者C++实现（一）
flyingshineangel的专栏
06-03 8751
和同学闲聊，谈到多线程中的经典问题——生产者-消费者问题：要求实现两个线程，一个线程负责对全局变量进行+1操作，一个线程负责打印更新后的值。自己从事code多年，自以为对多线程了解深入，不假思索，写出了下面的代码： #include <iostream> #include <mutex> #include <thread> #include <iost...
经典的进程同步问题-----生产者-消费者问题详解
热门推荐
丹丹的后花园
11-25 1万+
经典的进程同步问题-----生产者-消费者问题详解 ​ 本文和接下来几篇博文是对上篇文章（进程同步机制）的一次实践，通过具体的例子来加深理论的理解，会用三个经典的进程同步问题来进行讲解，并且会配有伪代码和Java实践（使用多线程模拟），深入的进行讲解。 ​ 进程同步问题是一个非常重要且相当有趣的问题，因而吸引了很多学者对他进行研究，比如在前几篇博客中提到的老熟人迪杰斯特拉，由此也产生了一系列经典的...
多线程设计模式:生产者-消费者
念念不忘，必有回响
09-03 2926
生产者，消费者：就好比厨师和食客，我们来看代码理解一下 https://www.cnblogs.com/xiaoxi/p/7910868.html https://www.jianshu.com/p/71a5089afe13
多线程-生产者和消费者模式
qq_42178122的博客
06-12 1515
多线程是多任务处理的一种特殊形式，多线程处理允许让一个进程中同时运行两个或两个以上的线程。这样的话，能更加充分发挥计算机的性能，并高效完成用户的任务。第一步：加入头文件 第二步：子线程的实现 第三步：创建线程 join和detach的对比： join()函数是一个等待线程完成函数，主线程需要等待子线程运行结束了才可以结束 detach()函数是子线程的分离函数，当调用该函数后，线程就被分离到后台运行，主线程不需要等待该线程结束才结束 上面代码的运行结果：显示打印hello thread，然后等待1秒后，在打
【Linux】多线程02 --- 线程的同步互斥问题及生产消费模型
阿润菜菜的博客
06-06 2220
线程的同步互斥问题及生产消费模型
Java--多线程之生产者消费者模式；线程池ExecutorService（五）
MinggeQingchun的博客
10-12 1981
生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的。纵观大多数设计模式，都会找一个第三者出来进行解耦，如工厂模式的第三者是工厂类，模板模式的第三者是模板类在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。
procon.rar_ProCon.d_生产 者－ 消费者 问题_生产者
09-24
生产者-消费者问题是一个经典的多线程同步问题，它源于计算机科学中的并发编程领域。这个问题由计算机科学家Edsger W. Dijkstra提出，主要探讨如何在多线程环境下有效地管理和控制资源的生产和消费，以避免数据竞争...
PC.rar_pv操作_生产者消费者_生产者－消费者问题
09-20
生产者-消费者问题是一个经典的多线程同步问题，在计算机科学和操作系统领域中有着广泛的应用。这个问题涉及到了进程通信和资源管理，通常通过PV操作（即P操作和V操作，也称为信号量机制）来解决。PV操作是荷兰...
consumer_producer.rar_操作系统_生产 消费_生产者－消费者问题_进程调度
09-22
在操作系统领域，生产者-消费者问题是多线程和进程同步的经典模型，用于描述并发执行的生产者进程与消费者进程如何共享资源而不会产生数据竞争或死锁的现象。在这个问题中，生产者负责生成数据，而消费者则负责消费...
开发多线程程序时，需要注意那些问题
最新发布
OO_SEN的博客
08-23 420
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
笔记redis
风止的博客
08-22 776
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 561
@Transactional中使用线程锁导致了锁失效与解决方案
android apk 加固后的地图加载异常及重新签名
calivnBao的博客
08-20 259
android apk 加固后的地图加载异常及重新签名
Java实现操作系统生产者-消费者问题
在操作系统中，生产者-消费者问题是多线程编程中的一个经典同步问题。这个问题模拟了生产者（产生资源）和消费者（消耗资源）之间的交互。在这个课程设计中，学生需要利用操作系统提供的机制，如信号量或Java的线程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值