多线程学习笔记-4.多线程并发控制流程

已于 2022-09-05 16:31:45 修改
阅读量426 收藏 3
点赞数 1
分类专栏： Java多线程与高并发学习 文章标签： 学习 java
于 2022-08-31 21:26:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xingzhes_/article/details/126569106
版权

@TOC

1. 什么是控制并发流程


在这里插入图片描述

2. CountDownLatch

在这里插入图片描述

2.1 类的作用

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

2.2 两个经典用法

1. 一个线程等待多个线程
  • 一个线程等待多个线程都在执行完毕，再继续自己的工作
/**
 * 描述：     工厂中，质检，5个工人检查，所有人都认为通过，才通过
 */
public class CountDownLatchDemo1 {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(5);// 5个等待线程
        ExecutorService service = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++) {
            final int no = i + 1;
            Runnable runnable = new Runnable() {

                @Override
                public void run() {
                    try {
                        Thread.sleep((long) (Math.random() * 10000));
                        System.out.println("No." + no + "完成了检查。");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        latch.countDown();// 每个线程休眠后，会进行一次计数
                    }
                }
            };
            service.submit(runnable);
        }
        System.out.println("等待5个人检查完.....");
        latch.await();// 进行等待
        System.out.println("所有人都完成了工作，进入下一个环节。");
    }
}


等待5个人检查完.....
No.1完成了检查。
No.4完成了检查。
No.3完成了检查。
No.5完成了检查。
No.2完成了检查。
所有人都完成了工作，进入下一个环节。
2. 多等1
/**
 * 描述：     模拟100米跑步，5名选手都准备好了，只等裁判员一声令下，所有人同时开始跑步。
 */
public class CountDownLatchDemo2 {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch begin = new CountDownLatch(1);
        ExecutorService service = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++) {
            final int no = i + 1;
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    System.out.println("No." + no + "准备完毕，等待发令枪");
                    try {
                        begin.await();
                        System.out.println("No." + no + "开始跑步了");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            service.submit(runnable);
        }
        //裁判员检查发令枪...
        Thread.sleep(5000);
        System.out.println("发令枪响，比赛开始！");
        begin.countDown();
    }
}

No.2准备完毕，等待发令枪
No.5准备完毕，等待发令枪
No.4准备完毕，等待发令枪
No.1准备完毕，等待发令枪
No.3准备完毕，等待发令枪
发令枪响，比赛开始！
No.2开始跑步了
No.4开始跑步了
No.5开始跑步了
No.3开始跑步了
No.1开始跑步了
3. 两者结合使用
/**
 * 描述：     模拟100米跑步，5名选手都准备好了，只等裁判员一声令下，所有人同时开始跑步。当所有人都到终点后，比赛结束。
 */
public class CountDownLatchDemo1And2 {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch begin = new CountDownLatch(1);

        CountDownLatch end = new CountDownLatch(5);
        ExecutorService service = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++) {
            final int no = i + 1;
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    System.out.println("No." + no + "准备完毕，等待发令枪");
                    try {
                        begin.await(); // 阻塞，等待裁判枪声
                        System.out.println("No." + no + "开始跑步了");
                        Thread.sleep((long) (Math.random() * 10000));
                        System.out.println("No." + no + "跑到终点了");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        end.countDown();
                    }
                }
            };
            service.submit(runnable);
        }
        //裁判员检查发令枪...
        Thread.sleep(5000);
        System.out.println("发令枪响，比赛开始！");
        begin.countDown();

        end.await(); // 阻塞，等待所有运动员准备
        System.out.println("所有人到达终点，比赛结束");
    }
}

No.1准备完毕，等待发令枪
No.3准备完毕，等待发令枪
No.2准备完毕，等待发令枪
No.5准备完毕，等待发令枪
No.4准备完毕，等待发令枪
发令枪响，比赛开始！
No.1开始跑步了
No.5开始跑步了
No.2开始跑步了
No.3开始跑步了
No.4开始跑步了
No.5跑到终点了
No.3跑到终点了
No.4跑到终点了
No.2跑到终点了
No.1跑到终点了
所有人到达终点，比赛结束

在这里插入图片描述

3. Semaphore信号量

3.1 作用

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

3.2 应用实例

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

3.3 使用流程和重要方法

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

  • 代码演示
  • 基本用法
package flowcontrol.semaphore;

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

/**
 * 描述：     演示Semaphore用法
 */
public class SemaphoreDemo {
    // 1. 构造方法
    static Semaphore semaphore = new Semaphore(5, true);

    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(50);
        for (int i = 0; i < 100; i++) {
            service.submit(new Task());
        }
        service.shutdown();
    }

    static class Task implements Runnable {

        @Override
        public void run() {
            try {
                // 2. 获取信号量方法
//                semaphore.acquire(3);
                semaphore.acquire();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "拿到了许可证");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "释放了许可证");
            // 3. 释放信号量方法
            semaphore.release(2);
        }
    }
}


pool-1-thread-2拿到了许可证
pool-1-thread-1拿到了许可证
pool-1-thread-3拿到了许可证
pool-1-thread-5拿到了许可证
pool-1-thread-6拿到了许可证 // 最多并发执行5个线程
pool-1-thread-2释放了许可证
pool-1-thread-3释放了许可证
pool-1-thread-1释放了许可证
pool-1-thread-5释放了许可证
pool-1-thread-4拿到了许可证
pool-1-thread-6释放了许可证
...
  • 特殊用法
    在这里插入图片描述
  • 注意释放数量与获取的数量相等
package flowcontrol.semaphore;

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

/**
 * 描述：     演示Semaphore用法
 */
public class SemaphoreDemo {
    // 1. 构造方法
    static Semaphore semaphore = new Semaphore(3, true);

    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(50);
        for (int i = 0; i < 100; i++) {
            service.submit(new Task());
        }
        service.shutdown();
    }

    static class Task implements Runnable {

        @Override
        public void run() {
            try {
                // 2. 获取信号量方法
                semaphore.acquire(3); // 一次拿到3个许可证
//                semaphore.acquire();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "拿到了许可证");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "释放了许可证");
            // 3. 释放信号量方法
            semaphore.release(3); // 1次释放3个
        }
    }
}


pool-1-thread-1拿到了许可证
pool-1-thread-1释放了许可证
pool-1-thread-2拿到了许可证
pool-1-thread-2释放了许可证
pool-1-thread-3拿到了许可证
pool-1-thread-3释放了许可证
pool-1-thread-4拿到了许可证
pool-1-thread-4释放了许可证
pool-1-thread-5拿到了许可证
...

3.4 注意点

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

4. Candition 接口(条件对象）

4.1 作用

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

4.2 代码演示

演示condition的基本用法
package flowcontrol.condition;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 描述：     演示Condition的基本用法
 */
public class ConditionDemo1 {
    private ReentrantLock lock = new ReentrantLock(); // 绑定在锁上
    private Condition condition = lock.newCondition();

    void method1() throws InterruptedException {
        lock.lock();
        try{
            System.out.println("条件不满足，开始await");
            condition.await();
            System.out.println("条件满足了，开始执行后续的任务");
        }finally {
            lock.unlock();
        }
    }

    void method2() {
        lock.lock();
        try{
            System.out.println("准备工作完成，唤醒其他的线程");
            condition.signal();
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ConditionDemo1 conditionDemo1 = new ConditionDemo1();
        new Thread(new Runnable() { // 第二个线程唤醒主线程
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                    conditionDemo1.method2();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        conditionDemo1.method1(); // 要先启动第二个线程，再运行主线程的wait方法
    }
}


条件不满足，开始await
准备工作完成，唤醒其他的线程
条件满足了，开始执行后续的任务

Process finished with exit code 0
实现生产者和消费者模式
package flowcontrol.condition;

import java.util.PriorityQueue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 描述：     演示用Condition实现生产者消费者模式
 */
public class ConditionDemo2 {

    private int queueSize = 10; // 中介:队列大小
    private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(queueSize);
    private Lock lock = new ReentrantLock();
    private Condition notFull = lock.newCondition(); // 给生产者用，没有满
    private Condition notEmpty = lock.newCondition();// 给消费者用，不空

    public static void main(String[] args) {
        ConditionDemo2 conditionDemo2 = new ConditionDemo2();
        Producer producer = conditionDemo2.new Producer();
        Consumer consumer = conditionDemo2.new Consumer();
        producer.start();
        consumer.start();
    }

    class Consumer extends Thread {

        @Override
        public void run() {
            consume();
        }

        private void consume() {
            while (true) {
                lock.lock();
                try {
                    while (queue.size() == 0) {
                        System.out.println("队列空，等待数据");
                        try {
                            notEmpty.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    queue.poll();
                    notFull.signalAll(); // 有空闲，唤醒生产者
                    System.out.println("从队列里取走了一个数据，队列共" + queue.size() + "个元素");
                } finally {
                    lock.unlock();
                }
            }
        }
    }

    class Producer extends Thread {

        @Override
        public void run() {
            produce();
        }

        private void produce() {
            while (true) {
                lock.lock();
                try {
                    while (queue.size() == queueSize) {
                        System.out.println("队列满，等待有空余");
                        try {
                            notFull.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    queue.offer(1);
                    notEmpty.signalAll();
                    System.out.println("向队列插入了一个元素，队列剩余空间" + (queueSize - queue.size()));
                } finally {
                    lock.unlock();
                }
            }
        }
    }

}


从队列里取走了一个数据，队列共9个元素
从队列里取走了一个数据，队列共8个元素
向队列插入了一个元素，队列剩余空间1
向队列插入了一个元素，队列剩余空间0
队列满，等待有空余
从队列里取走了一个数据，队列共9个元素
从队列里取走了一个数据，队列共8个元素
从队列里取走了一个数据，队列共7个元素
从队列里取走了一个数据，队列共6个元素
从队列里取走了一个数据，队列共5个元素
从队列里取走了一个数据，队列共4个元素
从队列里取走了一个数据，队列共3个元素
从队列里取走了一个数据，队列共2个元素
从队列里取走了一个数据，队列共1个元素
从队列里取走了一个数据，队列共0个元素
队列空，等待数据
向队列插入了一个元素，队列剩余空间9
向队列插入了一个元素，队列剩余空间8
向队列插入了一个元素，队列剩余空间7
向队列插入了一个元素，队列剩余空间6
向队列插入了一个元素，队列剩余空间5
向队列插入了一个元素，队列剩余空间4
向队列插入了一个元素，队列剩余空间3
向队列插入了一个元素，队列剩余空间2
向队列插入了一个元素，队列剩余空间1
...

4.3 注意点

在这里插入图片描述

  • 并且await更加灵活，可以对一个锁绑定多个condition条件

5. CycliBarrier循环栅栏

5.1 与CountDownLatch的作用比较

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

5.2 代码展示

package flowcontrol.cyclicbarrier;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * 描述：    演示CyclicBarrier
 */
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, new Runnable() { //5个线程都到了后，触发任务
            @Override
            public void run() {
                System.out.println("这批人都到场了， 大家统一出发！");
            }
        });
        for (int i = 0; i < 10; i++) { // 可重复，循环进行
            new Thread(new Task(i, cyclicBarrier)).start();
        }
    }
    // 执行具体任务
    static class Task implements Runnable{
        private int id;
        private CyclicBarrier cyclicBarrier;

        public Task(int id, CyclicBarrier cyclicBarrier) {
            this.id = id;
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            System.out.println("线程" + id + "现在前往集合地点");
            try {
                Thread.sleep((long) (Math.random()*10000));
                System.out.println("线程"+id+"到了集合地点，开始等待其他人到达");
                cyclicBarrier.await();
                System.out.println("线程"+id+"出发了");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }
}


"D:\Program Files\Java\jdk1.8.0_152\bin\java.exe" "-javaagent:D:\program files\JetBrains\IntelliJ IDEA 2020.3.1\lib\idea_rt.jar=53130:D:\program files\JetBrains\IntelliJ IDEA 2020.3.1\bin" -Dfile.encoding=UTF-8 -classpath "D:\program files\Java\jdk1.8.0_152\jre\lib\charsets.jar;D:\program files\Java\jdk1.8.0_152\jre\lib\deploy.jar;D:\program files\Java\jdk1.8.0_152\jre\lib\ext\access-bridge-64.jar;D:\program files\Java\jdk1.8.0_152\jre\lib\ext\cldrdata.jar;D:\program files\Java\jdk1.8.0_152\jre\lib\ext\dnsns.jar;D:\program files\Java\jdk1.8.0_152\jre\lib\ext\jaccess.jar;D:\program files\Java\jdk1.8.0_152\jre\lib\ext\jfxrt.jar;D:\program files\Java\jdk1.8.0_152\jre\lib\ext\localedata.jar;D:\program files\Java\jdk1.8.0_152\jre\lib\ext\nashorn.jar;D:\program files\Java\jdk1.8.0_152\jre\lib\ext\sunec.jar;D:\program files\Java\jdk1.8.0_152\jre\lib\ext\sunjce_provider.jar;D:\program files\Java\jdk1.8.0_152\jre\lib\ext\sunmscapi.jar;D:\program files\Java\jdk1.8.0_152\jre\lib\ext\sunpkcs11.jar;D:\program files\Java\jdk1.8.0_152\jre\lib\ext\zipfs.jar;D:\program files\Java\jdk1.8.0_152\jre\lib\javaws.jar;D:\program files\Java\jdk1.8.0_152\jre\lib\jce.jar;D:\program files\Java\jdk1.8.0_152\jre\lib\jfr.jar;D:\program files\Java\jdk1.8.0_152\jre\lib\jfxswt.jar;D:\program files\Java\jdk1.8.0_152\jre\lib\jsse.jar;D:\program files\Java\jdk1.8.0_152\jre\lib\management-agent.jar;D:\program files\Java\jdk1.8.0_152\jre\lib\plugin.jar;D:\program files\Java\jdk1.8.0_152\jre\lib\resources.jar;D:\program files\Java\jdk1.8.0_152\jre\lib\rt.jar;E:\Java学习笔记\java笔记\2.java基础知识\java并发\concurrency_tools_practice-master\out\production\concurrency_tools_practice-master" flowcontrol.cyclicbarrier.CyclicBarrierDemo
线程1现在前往集合地点
线程2现在前往集合地点
线程0现在前往集合地点
线程3现在前往集合地点
线程4现在前往集合地点
线程6现在前往集合地点
线程7现在前往集合地点
线程5现在前往集合地点
线程8现在前往集合地点
线程9现在前往集合地点
线程6到了集合地点，开始等待其他人到达
线程8到了集合地点，开始等待其他人到达
线程1到了集合地点，开始等待其他人到达
线程4到了集合地点，开始等待其他人到达
线程5到了集合地点，开始等待其他人到达
这批人都到场了， 大家统一出发！
线程5出发了
线程6出发了
线程1出发了
线程8出发了
线程4出发了
线程9到了集合地点，开始等待其他人到达
线程3到了集合地点，开始等待其他人到达
线程7到了集合地点，开始等待其他人到达
线程2到了集合地点，开始等待其他人到达
线程0到了集合地点，开始等待其他人到达
这批人都到场了， 大家统一出发！
线程0出发了
线程9出发了
线程3出发了
线程2出发了
线程7出发了

Process finished with exit code 0
天生我才~~
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java分布式应用学习笔记05多线程下的并发同步器.pdf
11-29
java分布式应用学习笔记05多线程下的并发同步器.pdf
多线程的并发控制
weixin_30753873的博客
01-23 353
当有多个线程同时访问有限制的资源时会出现并发情况，此时可以使用‘信号量’来控制访问资源的线程数量 static void Main(string[] args) { int taskCount = 10;//总线程数 int seatCount = 4;//资源访问最大线程数量...
Java 多线程并发控制框架
iteye_10301的博客
09-06 117
Java 提供了语言级别的线程支持，所以在 Java 中使用多线程相对于 C，C++ 来说更简单便捷，但本文并不是介绍如何在 Java 中使用多线程来来解决诸如 Web services, Number crunching 或者 I/O processing 之类的问题。在本文中，我们将讨论如何实现一个 Java 多线程的运行框架以及我们是如何来控制线程的并发同步以及顺序执行的。 　　所面临的问...
什么是Java中的多线程并发控制？如何解决？
最新发布
wudixiuluo的博客
04-04 871
Java中的多线程并发控制主要指的是在多线程环境下，对共享资源的访问和修改进行控制和协调，以防止数据不一致或其他并发问题的出现。
多线程并发服务器编程
热门推荐
Skycrab
12-12 1万+
<!-- @page {margin-left:1.25in; margin-right:1.25in; margin-top:0.59in; margin-bottom:0.69in} h1 {margin-top:0.24in; margin-bottom:0.23in; line-height:200%; page-break-inside:avoid}
java 并发控制_JAVA多线程的并发控制
weixin_39966909的博客
02-12 172
java的多线程实现主要有两种，一种是继承Thread，一种是实现Runnable接口，这个是java最基本的多线程知识。这里要补充一下，runnable接口中的run方法是不返回任何内容的，如果想返回一个对象可以试试用concurrent包中的Callable接口来替换runable接口的实现Executor.submit(Callable instance) 将返回一个Futrue>实例...
多线程并发服务器搭建流程
zhunaichao1的博客
08-26 621
我们把能够同时处理多个客户端服务器称为并发服务器,并发服务器可分为多线程并发服务器，多进程并发服务器，IO多路复用并发服务器
JUC多线程学习个人笔记
07-08
JUC（Java Util Concurrent）是Java中用于并发编程的工具包，提供了一组接口和类，用于处理多线程和并发操作。JUC提供了一些常用的并发编程模式和工具，如线程池、并发集合、原子操作等。 JUC的主要特点包括： ...
JAVA并发编程实践-线程安全-学习笔记
07-20
线程安全就是对共享的、可变的状态进行管理，对象的状态就是它的数据，换句话说就是在不可控制的并发访问中保护数据。
4种多线程创建笔记.md
04-19
以上笔记是我总结4种Java的多线程的创建方式，这个笔记给有需要的人学习，一起增长知识，介绍了什么是进程，什么是线程，以及并发与并行的概念，还有线程池的使用
多线程并发和设计模式学习笔记(代码)
09-02
多线程并发从,学习笔记,代码+注释,从线程创建开始到多线程并发,相关锁以及一些设计模式等
多线程并发控制CountDownLatch和CyclicBarrier和Semaphore
huangleijay的专栏
09-05 256
多线程并发控制CountDownLatch和CyclicBarrier和Semaphore，检索，智能问答
多线程的并发控制（synchronized与ThreadLocal）
weixin_30243533的博客
09-06 126
synchronized 　　synchronized的4种用法： 　　　　1.方法声明时使用,线程获得的是成员锁. 　　　　2.对某一代码块使用,synchronized后跟括号,括号里是变量,线程获得的是成员锁. 　　　　3.synchronized后面括号里是一对象,此时,线程获得的是对象锁. 　　　　4.synchronized后面括号里是类,此时,线程获得的是对象锁. ...
Java常用技术：多线程编程与并发控制
Y18870954401的博客
07-18 266
在上面的代码中，我们创建了一个线程，并在其内部使用Lambda表达式定义了线程执行的任务。在上面的代码中，我们创建了多个线程并发执行，每个线程都通过synchronized关键字锁定了共享资源counter。通过这种方式，我们确保了多个线程对counter的访问是互斥的，从而避免了竞态条件和线程安全问题。通过使用线程池和并发控制，我们可以更好地管理和控制多个线程的执行，从而提高程序的。多线程编程是Java中实现并发的一种方式，它允许程序同时执行多个任务，从而提高程序的性能和响应能力。
java---多线程的并发控制
浮生若梦--JJ
04-24 452
★ synchronized必须锁的是对象，基本数据类型的变量不能当作对象锁。 ★ 要保证多线程使用的是同一个互斥锁（对象锁），才能进行同步。 ★ 死锁的两种情况： 1）多个线程共用同一个对象锁，互相等待。 2）互相持有对方所需的资源（即每个线程都需要同时拿到多个资源才能继续执行，而多个线程都处于：各持有一部分，在等待另一部分。） ★ 死锁的解决 要从设
多线程调优经验-并发控制方法
zhupanlinch的博客
02-20 324
写在前面◆ ◆ ◆◆并行程序开发将不可避免地要涉及多线程、多任务间的写作和数据共享等问题。在JDK中，提供了多种途径实现多线程间的并发控制。常用的方法有：内部锁、重入锁、读写锁、信号量...
“深入理解Java多线程编程：并发控制与同步机制解析“
jiheng1的博客
07-04 257
总结起来，深入理解Java多线程编程需要掌握并发控制和同步机制的原理和使用方法。通过合理地使用锁、原子操作、synchronized关键字等机制，可以保证多线程程序的正确性和性能。Java多线程编程是指在Java程序中使用多个线程来执行任务。多线程编程可以提高程序的并发性和性能，但也会带来一些并发控制和同步机制的问题。下面我将详细解析这些问题。除了上述机制外，Java还提供了一些高级的并发工具和数据结构，如线程池、阻塞队列等，它们能够帮助我们更方便地进行并发控制和同步。
线程的并发控制
wangrong111222的博客
09-22 654
并发是指一个对象多个线程同时操作 ，这样就会有问题， 一般会出现两种问题， 一种就是 某一块数据同时操作重复多次； 这个是由于各个线程有不同的线程都有不同的操作空间来和主存交互，如果a和主存拷贝数据，修改后没有提交到主存之前，b也拷贝了这个数据，那这个时候就会出现 这种情况； 另外就是会出现操作超了临界点的情况，到临界点的时候由于网络延迟，线程操作数据被延时，实际上早就应该停止，因为延迟，就...
java多线程并发控制_Java多线程与并发控制
weixin_31861847的博客
02-13 249
三、线程的几种状态在Java当中，线程通常都有五种状态，创建、就绪、运行、阻塞和死亡。第一是创建状态。在生成线程对象，并没有调用该对象的start方法，这是线程处于创建状态。第二是就绪状态。当调用了线程对象的start方法之后，该线程就进入了就绪状态，但是此时线程调度程序还没有把该线程设置为当前线程，此时处于就绪状态。在线程运行之后，从等待或者睡眠中回来之后，也会处于就绪状态。第三是运行状态。线程...
Java多线程编程学习笔记之十二：生产者—消费者模型（含代码）
06-02
生产者—消费者模型是一种常见的多线程并发模型，它涉及到两个角色：生产者和消费者。生产者负责生产数据，消费者负责消费数据。生产者和消费者通过一个共享的缓冲区进行通信，生产者将数据放入缓冲区，消费者从缓冲...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值