Java 多线程

最新推荐文章于 2023-11-28 09:26:43 发布
最新推荐文章于 2023-11-28 09:26:43 发布
阅读量285 收藏 1
点赞数
分类专栏： Java基础 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AmorFati1996/article/details/108783711
版权

1. 基本概念：程序、进程、线程

在这里插入图片描述
在这里插入图片描述

  1. 程序计数器、虚拟机栈每个线程有一份。
  2. 方法区、堆每个进程有一份。
  3. 多个线程共享进程中的方法区和堆。
    一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。
    在这里插入图片描述

何时需要多线程？

  • 程序需要同时执行两个或多个任务
  • 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
  • 需要一些后台运行的程序时。

2. 线程的创建和使用

在这里插入图片描述

线程的创建方式一：继承Thread类

package org.examle;

/**
 * 多线程的创建
 * 方式一：继承Thread类
 * 1. 创建一个Thread类的子类
 * 2. 重写run()方法
 * 3. 创建Thread类的子类的对象
 * 4. 通过对此对象调用start()
 * <p>
 * 例子：便利100以内的所有偶数
 * 改进：直接通过建立Thread类的匿名子类实现多线程
 */
public class ThreadTest {
    public static void main(String[] args) {
        //3. 创建Thread类的子类的对象
        MyThread t1 = new MyThread();
        //4. 通过对此对象调用start():1）启动当前线程 2）调用当前线程的run()方法
        t1.start();
        // 问题一：不可以直接使用t1.run()启动多线程;会发现没有开启新线程，只是调用了一个方法而已。
//        t1.run();
        // 问题二：再启动一个线程，不可以让已经start()的线程去执行。会报java.lang.IllegalThreadStateException.
//        t1.start();
        //需要重新创建一个线程的对象
        MyThread t2 = new MyThread();
        t2.start();
        //如下语句在main线程中运行
        System.out.println("hello");

        //直接通过建立Thread类的匿名子类实现多线程
        new Thread(){
            @Override
            public void run() {
                System.out.println("***");
            }
        }.start();
    }
}

//1. 创建一个Thread类的子类
class MyThread extends Thread {
    @Override
    //2. 重写run()方法
    public void run() {
        for (int i = 1; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
            }
        }
    }
}

Thread类中的常用的方法

package org.examle;

/**
 * 测试Thread中的常用方法：
 * 1. start():启动当前线程：调用当前线程的run().
 * 2. run(): 通常需要重写Thread类中的此方法，将将创建的线程要执行的操作声明在此方法中
 * 3. currentTread(): 静态方法，返回执行当前代码的线程
 * 4. getName(): 获取当前线程的名字
 * 5. setName(): 设置当前线程的名字
 * 6. yield(): 释放当前线程cpu的执行权
 * 7. join(): 在线程A中调用线程B的join()方法，线程A进入阻塞状态，知道线程B完全执行完以后，线程A才结束阻塞状态。
 * 8. stop(): 已过时。当执行此方法时，强制结束当前线程。
 * 9，sleep(long millis): 静态方法，让当前线程”睡眠“指定的millis毫秒，在指定的millis毫秒时间内，当前线程是阻塞状态。
 * 10. isAlive(): 判断当前线程是否存活
 *
 * 线程的优先级：
 * 1. MAX_PRIORITY = 10; MIN_PRIORITY = 1; NORM_PRIORITY = 5;
 * 2. 如何获取的设置当前线程的优先级：getPriority():获取；setPriority(int p): 设置。
 *
 *
 */
public class ThreadMethodTest {
    public static void main(String[] args) {
        HelloThread helloThread = new HelloThread();
        helloThread.setName("Hello");
        helloThread.setPriority(7);
        helloThread.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        for (int i = 0; i < 100; i++) {
            System.out.println("main:"+i);

            if (i == 20) {
                try {
                    helloThread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(helloThread.isAlive());
        System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority());
    }

}

class HelloThread extends Thread {

    //通过构造器给线程命名
    public HelloThread(String name){
        super(name);
    }

    public HelloThread() {
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            if (i % 10 == 0) {
                yield();
            }
        }
        System.out.println(getName()+":"+getPriority());
    }
}

创建多线程的方式二：实现Runnable接口

package org.examle;

/**
 * 创建多线程的方式二：实现Runnable接口
 * 1. 创建一个实现Runnable接口的类
 * 2. 实现类去实现Runnable接口中的抽象方法：run()
 * 3. 创建实现类的对象
 * 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
 * 5. 通过Thread类的对象调用start()方法。
 * <p>
 * 比较创建线程的两种方式：
 * 开发中优先选择实现Runnable接口的方式
 * 1. 实现的方式没有类的单继承的局限性
 * 2. 实现的方式更适合来处理多个线程有共享数据的方式
 *
 * 两者的联系：Thread 也实现了Runnable接口
 * 相同点，两种方式都需要重写run()，将线程要执行的逻辑声明在run()中。
 */
public class ThreadTest1 {
    public static void main(String[] args) {
//        3. 创建实现类的对象
        MThread mThread = new MThread();
//        4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread thread = new Thread(mThread);
//        5. 通过Thread类的对象调用start()方法。
        thread.start();
        //再创建一个线程实现遍历100以内的数，重复4，5步
        Thread t2 = new Thread(mThread);
        t2.start();
    }

}

//1. 创建一个实现Runnable接口的类
class MThread implements Runnable {
    //    2. 实现类去实现Runnable接口中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

3. 线程的生命周期

在这里插入图片描述
在这里插入图片描述

Thread类的内部枚举类State

线程的JVM状态

A thread state. A thread can be in one of the following states:

NEW A thread that has not yet started is in this state.

RUNNABLE A thread executing in the Java virtual machine is in 
this state.

BLOCKED A thread that is blocked waiting for a monitor lock is in
 this state.

WAITING A thread that is waiting indefinitely for another thread
 to perform a particular action is in this state.

TIMED_WAITING A thread that is waiting for another thread to
 perform an action for up to a specified waiting time is in 
 this state.

TERMINATED A thread that has exited is in this state.

A thread can be in only one state at a given point in time. 
These states are virtual machine states which do not reflect 
any operating system thread states.

4. 线程的同步

同步代码块处理线性安全问题

package org.examle;

/**
 * 例子：创建三个窗口卖票，总票数为100张。
 * 1. 问题：卖票过程中出现了重票和错票。
 * 2. 问题出现的原因：当某个线程操作车票的过程中，尚未完成操作，其他线程也开始操作车票
 * 3. 如何解决：当一个线程操作ticket的时候，其他线程不能参与进来，直到线程A操作完ticket时，
 * 其他线程才能操作。
 * 4. 在java中，我们通过同步机制，来解决线程安全问题。
 * 方式一：同步代码块
 * synchronized(同步监视器){
 *     //需要被同步的代码
 * }
 * 说明：1) 操作共享数据的代码，即为需要被同步的代码
 * 2)共享数据：多个线程共同操作的变量。比如：ticket。
 * 3) 同步监视器，俗称：锁。任何一个类的对象都可充当锁。
 * 要求：多个线程必须要共用同一把锁。（类的对象必须对多个线程唯一）。
 * 通过实现Runnable接口实现多线程时，可以考虑用this当锁。
 * 通过继承Thread类接口实现多线程时，可以考虑用类名.class当锁，如window.class.
 *
 * 方式二：同步方法
 *
 * 5. 同步的方式，解决了线程安全问题。----好处
 * 操作同步代码时，只有一个线程参与，其他线程等待。相当于一个单线程的过程，效率低。
 *
 */
public class WindowTest1 {
    public static void main(String[] args) {
        Windows w1 = new Windows();
        Thread t1 = new Thread(w1);
        Thread t2 = new Thread(w1);
        Thread t3 = new Thread(w1);
        t1.start();
        t2.start();
        t3.start();
    }

}

class Windows implements Runnable {
    private int ticket = 100;
    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+": 卖票，票号为：" + ticket);
                    ticket--;
                }else {
                    break;
                }
            }

        }
    }
}

同步方法处理线性安全问题

package org.examle;

/**
 * 方式二：使用同步方法解决线程安全问题
 * <p>
 * 关于同步方法的总结：
 * 1. 同步方法仍然涉及到同步监视器，质是不需要我们显示的声明
 * 2. 非静态的同步方法，同步监视器是：this
 * 静态的同步方法，同步监视器是：当前类本身
 */
public class WindowTest3 {
    public static void main(String[] args) {
        Window3 w1 = new Window3();
        Thread t1 = new Thread(w1);
        Thread t2 = new Thread(w1);
        Thread t3 = new Thread(w1);
        t1.start();
        t2.start();
        t3.start();
    }

}

class Window3 implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }
    //同步监视器 当前类本身，使用同步方法的方式解决继承Thread类的的线程安全问题
    //    private static synchronized void show(){};
    //同步监视器 this, 使用同步方法的方式解决实现Runnable接口的线程安全问题
    private synchronized void show() {
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ": 卖票，票号为：" + ticket);
            ticket--;
        }
    }
}

在这里插入图片描述
在这里插入图片描述

package org.example2;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 解决线程安全问题的方式三：Lock锁 ---jdk5.0新增
 *
 * 1. 面试题：synchronized与lock的异同？
 * 相同点：二者都可以解决线程安全问题
 * 不同点：synchronized 机制在执行完相应的同步代码后，自动的释放同步监视器
 * Lock 需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）.
 */
public class LockTest {
    public static void main(String[] args) {
        Window w1 = new Window();
        Thread t1 = new Thread(w1);
        Thread t2 = new Thread(w1);
        Thread t3 = new Thread(w1);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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


class Window implements Runnable {
    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @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();
            }
        }
    }
}

在这里插入图片描述
详细的Lock用法以及Condition用法参考这里。（Condition是如何通过Lock实现线程通信的接口）

5. 线程的通信

package org.example2;

/**
 * 线程通信的例子：使用两个线程打印1-100。线程1，线程2交替打印。
 *
 * 涉及到的三个方法：
 * wait(): 一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
 * notify(): 一旦执行此方法，就会唤醒被wait的一个线程，如果有多个线程wait,
 * 就会唤醒优先级高的线程
 * notifyAll(): 一旦执行此方法：就会唤醒所有被wait的线程。
 *
 * 说明：
 * 1. wait(), notify(), notifyAll()必须使用在同步代码块或同步方法中。
 * 2. wait(), notify(), notifyAll()的调用者必须时同步代码块或同步方法中的同步监视器，
 * 否则，会出现IllegalMonitorStateException异常
 * 3. wait(), notify(), notifyAll()定义在java.lang.Ojbect类中。
 *
 * 面试题：sleep()和wait()的异同？
 * 1.相同点：一旦执行方法，当前线程进入阻塞状态。
 * 2.不同点：1）两个方法的声明位置不同，sleep()声明在Thread类中， wait()声明在Object类中
 *          2）调用的要求不同：sleep()可以在任何需要的场景下调用，wait()必须使用在同步代码块
 *          或同步方法中。
 *          3）关于是否释放同步监视器：sleep()不会释放同步监视器，wait()会释放同步监视器。
 */
public class CommunicationTest {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        t2.start();
    }
}

class Number implements Runnable {
    private int num = 1;
    private Object obj = new Object();


    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
//            synchronized (this) {
                obj.notifyAll();
//                notifyAll();
                if (num <= 100) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + num);
                    num++;
                    try {//使得调用wait()方法的线程进入阻塞状态
                        obj.wait();
//                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}

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

package org.example2;

/**
 * 线程通信的应用：生产者、消费者问题
 * 生产者生产产品交给店员，消费者从店员处取走产品，店员只能持有固定数量的产品（如：20），
 * 如果生产者试图生产更多的产品，店员会叫停一下，如果店中有空位，则通知生产者继续生产，
 * 如果店中没有产品，店员会告诉消费者等一下，如果店中有产品了，则通知消费者取走产品。
 */
public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producer p1 = new Producer(clerk);
        Customer c1 = new Customer(clerk);
        p1.start();
        c1.start();

    }
}

class Clerk {

    private int productNumber = 0;

    public synchronized void produceProduct() {
        if (productNumber < 20) {
            productNumber++;
            System.out.println(Thread.currentThread().getName()+":开始生产第"+productNumber+"产品");
            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void buyProduct() {
        if (productNumber > 0) {
            System.out.println(Thread.currentThread().getName() + "消费了第" + productNumber + "产品");
            productNumber--;
            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 {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduct();
        }
    }
}

class Customer extends Thread {
    private Clerk clerk;

    public Customer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(getName()+":开始购买产品");
        while (true) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.buyProduct();
        }
    }
}

6. JDK5.0新增线程的创建方式

新增方式一：实现Callable接口

在这里插入图片描述

package org.example3;

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

/**
 * 创建线程的方式三：实现Callable接口 ---jdk5.0新增
 * <p>
 * 如何理解实现Callable接口的方式创建多线程比Runnable强大？
 * 1. call()方法可以有返回值
 * 2. call()方法可以抛出异常，被外面的操作捕获，获取异常信息
 * 3. Callable是支持泛型的
 */
public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4. 将此Callable接口实现类的对象传递FutureTask构造器中，创建FutureTask对象
        FutureTask<Integer> futureTask = new FutureTask<>(numThread);
        //5. 将FutureTask对象传递到Thread类的构造器中，创建Thread对象，并调用start()方法。
        new Thread(futureTask).start();
        try {
            //6. 获取Callable实现类对象中call()方法的返回值
            // get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Integer sum = futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

//1. 创建一个实现Callable接口的实现类
class NumThread implements Callable<Integer> {

    //2. 实现call()方法，将此线程需要执行的操作声明在call()中
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

新增方式二：使用线性池

在这里插入图片描述
在这里插入图片描述

package org.example3;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 创建线程的方式四：使用线性池
 */
public class ThreadPool {
    public static void main(String[] args) {
        //1. 提供指定线程数量的线性池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //2. 执行指定的线性操作，需要提供实现Runnable接口或Callable接口的实现类的对象

        //设置线性池的属性
        ThreadPoolExecutor executor = (ThreadPoolExecutor) service;
//        executor.setKeepAliveTime();

        service.execute(new NumberThread());//适用于Runnable
//        service.submit();//适用于Runnable或Callable
        //3. 关闭连接池
        service.shutdown();

    }
}

class NumberThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
            }
        }
    }
}
AmorFati1996
关注
专栏目录
[C++] C++11 条件变量
jiang_T的博客
10-27 871
条件变量 C++11 提供了条件变量condition variable用于实现线程间的同步操作，需要包含头文件#include <condition_variable>，并且一般都是与互斥量mutex配合使用。 条件变量的工作方式为： 使用条件变量的线程首先对互斥量加锁 检查某个条件，如果条件不满足，则释放互斥锁量，进入休眠；如果条件满足，则继续执行资源操作，执行完操作后释放互斥量 另外一个线程加锁执行资源操作，使条件满足后，释放互斥量，唤醒等待的线程 具体参考：std::conditio
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
在使用 Response.End、Response.Redirect 或 Server.Transfer 时出现 ThreadAbortException
TonyChi 's Tech Space
02-26 2315
PRB：在使用 Response.End、Response.Redirect 或 Server.Transfer 时出现 ThreadAbortException最后修改 : 2005年10月24日 症状如果使用 Response.End、Response.Redirect 或 Server.Transfer 方法，将出现 ThreadAbortException 异常。您可以使用
多线程-面试题
龙兮
06-13 257
多线程 1. 并行和并发有什么区别？ 并行：多个处理器或多核处理器同时处理多个任务。 并发：多个任务在同一个 CPU 核上，按细分的时间片轮流(交替)执行，从逻辑上来看那些任务是同时执行。 如下图： 并发 = 两个队列和一台咖啡机。 并行 = 两个队列和两台咖啡机。 2. 线程和进程的区别？ 一个程序下至少有一个进程，一个进程下至少有一个线程，一个进程下也可以有多个线程来增加程序...
C++11 条件变量
jianfeng123123的博客
09-14 1995
互斥量是多线程间同时访问某一共享变量时，保证变量可被安全访问的手段。但单靠互斥量无法实现线 程的同步。线程同步是指线程间需要按照预定的先后次序顺序进行的行为。C++11对这种行为也提供了 有力的支持，这就是条件变量。条件变量位于头文件condition_variable下。条件变量使用过程：1. 拥有条件变量的线程获取互斥量；2. 循环检查某个条件，如果条件不满足则阻塞直到条件满足；如果条件满足则向下执行；
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
Java多线程Executors批量执行数据实现限流
05-20
Java多线程实现数据切割批量执行，实现限流操作。 java线程池Executors实现数据批量操作。 批量异步Executors处理数据，实现限流操作，QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合： 1.批量处理大数据。...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
C++11的条件变量
最新发布
qq_25048473的博客
11-28 433
C++11的条件变量
c++11 条件变量
woosky的博客
09-03 307
#include <iostream> #include <thread> #include <mutex> #include <condition_variable> using namespace std; condition_variable cv; mutex mu; bool isWork1Complete = false; bool ...
C++11 条件变量（condition_variable）
QtCompany的博客
02-22 231
在C++11中，我们可以使用条件变量（condition_variable）实现多个线程间的同步操作；当条件不满足时，相关线程被一直阻塞，直到某种条件出现，这些线程才会被唤醒。
C++11线程库 (六) 条件变量 Condition variables
Fishfishfishfishcat
03-03 4419
条件变量是一个线程同步术语，它允许多个线程相互通信。 他可以让一部分线程等待（可能超时）另一个线程可能发出的继续执行通知，条件变量与总是和互斥锁相关。————cppref对于条件变量的描述 一、为什么需要条件变量？ 简单来说，条件变量可以完成一些特定场合互斥锁不能（高效）完成的工作。他是多线程编程中“等待-唤起”逻辑的基础，条件变量利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；另一个线程使“条件成立”。等待端需要互斥锁的原因是防止在进入等待状态（.
c++11新特性之条件变量
delongwang520的博客
03-18 1232
std::condition_variable 是为了解决死锁而生的。当互斥操作不够用而引入的。比如，线程可能需要等待某个条件为真才能继续执行，而一个忙等待循环中可能会导致所有其他线程都无法进入临界区使得条件为真时，就会发生死锁。所以，condition_variable实例被创建出现主要就是用于唤醒等待线程从而避免死锁。std::condition_variable的 notify_one()用于
[c++11]多线程编程(六)——条件变量(Condition Variable)
weixin_34007906的博客
09-02 346
互斥锁std::mutex是一种最常见的线程间同步的手段，但是在有些情况下不太高效。 假设想实现一个简单的消费者生产者模型，一个线程往队列中放入数据，一个线程往队列中取数据，取数据前需要判断一下队列中确实有数据，由于这个队列是线程间共享的，所以，需要使用互斥锁进行保护，一个线程在往队列添加数据的时候，另一个线程不能取，反之亦然。用互斥锁实...
Java多线程深度解析
"《Java多线程详解》- 汪文君" 本书是关于Java多线程编程的深度解析，作者汪文君分享了他在工作中和学习中的理解和实践经验。书中内容详细介绍了多线程的基本概念、Java对多线程的支持以及如何在实际编程中运用多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值