死锁，线程协作(同步，阻塞队列，Condition，管道流)
synchronized死锁
package com.thread.demo.deadlock;
public class DeadLock {
private static Object lock1 = new Object();
private static Object lock2 = new Object();
public static void main(String[] args) {
// 创建线程1
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
synchronized (lock1) {
System.out.println(Thread.currentThread().getName() + "获取到lock1这把锁");
System.out.println(Thread.currentThread().getName() + "等待lock2锁..........");
synchronized (lock2) {
System.out.println(Thread.currentThread().getName() + "获取到lock2这把锁");
}
}
}
}
}, "A线程").start();
// 创建的线程2
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
synchronized (lock2) {
System.out.println(Thread.currentThread().getName() + "获取到lock2这把锁");
System.out.println(Thread.currentThread().getName() + "等待lock1锁..........");
synchronized (lock1) {
System.out.println(Thread.currentThread().getName() + "获取到lock1这把锁");
}
}
}
}
}, "B线程").start();
}
}
ReentrantLock死锁
package com.thread.demo.deadlock; import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock; public class ReentrantDeadLock {
private static Lock lock = new ReentrantLock(); public static void main(String[] args) {
new Thread(new MyRunnable(lock), "一线程").start();
new Thread(new MyRunnable(lock), "二线程").start();
} } class MyRunnable implements Runnable { private Lock lock;
private static int count = 0; public MyRunnable(Lock lock) {
this.lock = lock;
} @Override
public void run() {
lock.lock(); try {
for (int i = 0; i < 100000000; i++) {
count++; if (i == 100000) {
throw new RuntimeException();
}
}
System.out.println(Thread.currentThread().getName() + ":count=" + count);
} catch(Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
} } }
wait，notify，notifyAll 必须结合synchronized关键字使用
package com.thread.demo.cooperation; /**
* wait，notify，notifyAll 必须结合synchronized关键字使用
*
* @author Administrator
*
*/
public class Demo1 { public static void main(String[] args) {
// 创建共享池
Container container = new Container();
new MyThread(container).start();
new MyThread(container).start();
new MyThread(container).start();
new MyThread1(container).start();
new MyThread1(container).start();
new MyThread1(container).start();
}
} class MyThread extends Thread {
private Container container; public MyThread(Container container) {
this.container = container;
} @Override
public void run() {
container.get();
}
} class MyThread1 extends Thread {
private Container container; public MyThread1(Container container) {
this.container = container;
} @Override
public void run() {
container.put();
}
} class Container {
boolean flag = true; public synchronized void put() {
while (true) {
if (!flag) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + "放入内容.......");
flag = false;
// 唤醒拿内容线程
notifyAll();
}
} public synchronized void get() {
while (true) {
if (flag) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + "拿出内容.......");
flag = true;
notifyAll();
}
}
}
使用synchronized实现生产消费者模式
package com.thread.demo.cooperation; /**
* 使用synchronized实现生产消费者模式
* @author Administrator
*
*/
public class Demo2 {
public static void main(String[] args) {
AppleContainer container = new AppleContainer();
new Thread(new Producer(container),"AA").start();
new Thread(new Consumer(container),"BB").start();
}
} // 生产者
class Producer implements Runnable { private AppleContainer container; public Producer(AppleContainer container) {
this.container = container;
} @Override
public void run() { for (int i = 0; i < 10; i++) {
try {
System.out.println("生产----------------------苹果:" + (i+1));
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO: handle exception
e.printStackTrace();
} container.increace();
}
}
} // 消费者
class Consumer implements Runnable { private AppleContainer container; public Consumer(AppleContainer container) {
this.container = container;
} @Override
public void run() { for (int i = 0; i < 10; i++) {
try {
System.out.println(Thread.currentThread().getName()+"消费----------------------苹果:" + (i+1));
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO: handle exception
e.printStackTrace();
} container.decreace();
} }
} class AppleContainer {
private int apple; public synchronized void increace() {
if (apple == 5) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
} }
apple++;
System.out.println("生产有苹果:"+apple);
notifyAll();
} public synchronized void decreace() {
if (apple == 0) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
apple--;
System.out.println("消费有苹果:"+apple);
notifyAll();
}
}
使用阻塞队列实现生产消费者模式
package com.thread.demo.cooperation; import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue; /**
* 使用阻塞队列实现生产消费者模式
* @author Administrator
*
*/
public class Demo3 {
public static void main(String[] args) {
// 创建阻塞队列（先进先出）
BlockingQueue<Integer> proQueue = new LinkedBlockingQueue<>(4);
new Thread(new ProducerQueue(proQueue),"AA").start();
new Thread(new ConsumerQueue(proQueue),"BB").start();
}
} class ProducerQueue implements Runnable { private BlockingQueue<Integer> proQueue; public ProducerQueue(BlockingQueue<Integer> proQueue) {
this.proQueue = proQueue;
} @Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("生产了编号为:"+i);
try {
Thread.sleep(1000);
proQueue.put(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} } class ConsumerQueue implements Runnable { private BlockingQueue<Integer> proQueue; public ConsumerQueue(BlockingQueue<Integer> proQueue) {
this.proQueue = proQueue;
} @Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
System.out.println("消费了编号为:"+proQueue.take());
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
} }
} }
lock实现生产消费者模式
package com.thread.demo.cooperation; import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock; public class Demo4 {
public static void main(String[] args) {
Basket b = new Basket();
Product p = new Product(b);
ConsumerCondition c = new ConsumerCondition(b);
ConsumerCondition c1 = new ConsumerCondition(b);
new Thread(p,"生产者1").start();
new Thread(c,"消费者1").start();
new Thread(c1,"消费者2").start();
}
} // 馒头
class ManTou {
int id; public ManTou(int id) {
this.id = id;
} @Override
public String toString() {
return "ManTou" + id;
}
} // 装馒头的篮子
class Basket {
int max = 6;
LinkedList<ManTou> manTous = new LinkedList<ManTou>();
Lock lock = new ReentrantLock(); // 锁对象
Condition full = lock.newCondition(); // 用来监控篮子是否满的Condition实例
Condition empty = lock.newCondition(); // 用来监控篮子是否空的Condition实例
// 往篮子里面放馒头 public void push(ManTou m) {
lock.lock();
try {
while (max == manTous.size()) {
System.out.println("篮子是满的，待会儿再生产...");
full.await(); // wait
}
manTous.add(m);
empty.signalAll(); // notfiy
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
} // 往篮子里面取馒头
public ManTou pop() {
ManTou m = null;
lock.lock();
try {
while (manTous.size() == 0) {
System.out.println("篮子是空的，待会儿再吃...");
empty.await();
}
m = manTous.removeFirst();
full.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock(); }
return m;
}
} // 生产者
class Product implements Runnable {
Basket basket; public Product(Basket basket) {
this.basket = basket;
} public void run() {
for (int i = 0; i < 10; i++) {
ManTou m = new ManTou(i);
basket.push(m);
System.out.println(Thread.currentThread().getName()+"生产了" + m);
try {
Thread.sleep((int) (Math.random() * 2000));
} catch (InterruptedException e) {
e.printStackTrace();
} }
}
} // 消费者
class ConsumerCondition implements Runnable {
Basket basket; public ConsumerCondition(Basket basket) {
this.basket = basket;
} public void run() {
for (int i = 0; i < 5; i++) {
try {
Thread.sleep((int) (Math.random() * 2000));
} catch (InterruptedException e) {
e.printStackTrace();
}
ManTou m = basket.pop();
System.out.println(Thread.currentThread().getName()+"消费了" + m);
}
}
}
管道输入输出流实现生产消费者模式
package com.thread.demo.cooperation; import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream; public class Demo5 { public static void main(String[] args) {
/**
* 创建管道输出流
*/
PipedOutputStream pos = new PipedOutputStream();
/**
* 创建管道输入流
*/
PipedInputStream pis = new PipedInputStream();
try {
/**
* 将管道输入流与输出流连接 此过程也可通过重载的构造函数来实现
*/
pos.connect(pis);
} catch (IOException e) {
e.printStackTrace();
}
/**
* 创建生产者线程
*/
PipeProducer p = new PipeProducer(pos, "CCC");
/**
* 创建消费者线程
*/
PipeProducerConsumer c1 = new PipeProducerConsumer(pis, "AAA");
PipeProducerConsumer c2 = new PipeProducerConsumer(pis, "BBB");
/**
* 启动线程
*/
p.start();
c1.start();
c2.start();
}
} /**
* 生产者线程(与一个管道输入流相关联)
*
*/
class PipeProducer extends Thread {
private PipedOutputStream pos; public PipeProducer(PipedOutputStream pos, String name) {
super(name);
this.pos = pos; } public void run() {
int i = 0;
try {
while (true) {
Thread.sleep(3000);
System.out.println(Thread.currentThread().getName() + "product:" + i);
pos.write(i);
i++;
}
} catch (Exception e) {
e.printStackTrace();
}
}
} /**
* 消费者线程(与一个管道输入流相关联)
*
*/
class PipeProducerConsumer extends Thread {
private PipedInputStream pis; public PipeProducerConsumer(PipedInputStream pis, String name) {
super(name);
this.pis = pis;
} public void run() {
try {
while (true) {
System.out.println(Thread.currentThread().getName() + "consumer1:" + pis.read());
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
死锁，线程协作(同步，阻塞队列，Condition，管道流)的更多相关文章
- 一天十道Java面试题----第三天（对线程安全的理解------＞线程池中阻塞队列的作用）
这里是参考B站上的大佬做的面试题笔记.大家也可以去看视频讲解!!! 文章目录 21.对线程安全的理解 22.Thread和Runnable的区别 23.说说你对守护线程的理解 24.ThreadLoc ...
- java 线程池线程忙碌且阻塞队列也满了时给一个拒接的详细报告
线程池线程忙碌且阻塞队列也满了时给一个拒接的详细报告.下面是一个自定义的终止策略类,继承了ThreadPoolExecutor.AbortPolicy类并覆盖了rejectedExecution方法把 ...
- c++ 同步阻塞队列
参考:<C++11深入应用> 用同步阻塞队列解决生产者消费者问题. 生产者消费者问题: 有一个生产者在生产产品,这些产品将提供给若干个消费者去消费,为了使生产者和消费者能并发执行,在两者之 ...
- 线程高级应用-心得7-java5线程并发库中阻塞队列Condition的应用及案例分析
1.阻塞队列知识点 阻塞队列重要的有以下几个方法,具体用法可以参考帮助文档:区别说的很清楚,第一个种方法不阻塞直接抛异常:第二种方法是boolean型的,阻塞返回flase:第三种方法直接阻塞. 2. ...
- 源码剖析ThreadPoolExecutor线程池及阻塞队列
本文章对ThreadPoolExecutor线程池的底层源码进行分析,线程池如何起到了线程复用.又是如何进行维护我们的线程任务的呢?我们直接进入正题: 首先我们看一下ThreadPoolExecuto ...
- Java：阻塞队列
Java:阻塞队列 本笔记是根据bilibili上 尚硅谷 的课程 Java大厂面试题第二季 而做的笔记 1. 概述 概念 队列 队列就可以想成是一个数组,从一头进入,一头出去,排队买饭 阻塞队列 B ...
- 阻塞队列---ArrayBlockingQueue，LinkedBlockingQueue，DelayQueue源码分析
阻塞队列和非阻塞队列阻塞队列和非阻塞队列的区别:阻塞队列可以自己阻塞,非阻塞队列不能自己阻塞,只能使用队列wait(),notify()进行队列消息传送.而阻塞队列当队列里面没有值时,会阻塞直到有值输 ...
- java高并发系列 - 第25天：掌握JUC中的阻塞队列
这是java高并发系列第25篇文章. 环境:jdk1.8. 本文内容 掌握Queue.BlockingQueue接口中常用的方法 介绍6中阻塞队列,及相关场景示例 重点掌握4种常用的阻塞队列 Queu ...
- 【JUC】阻塞队列&生产者和消费者
阻塞队列 线程1往阻塞队列添加元素[生产者] 线程2从阻塞队列取出元素[消费者] 当队列空时,获取元素的操作会被阻塞 当队列满时,添加元素的操作会被阻塞 阻塞队列的优势:在多线程领域,发生阻塞时,线程 ...
随机推荐
- javascript中构造函数的说明
1.1 构造函数是一个模板 构造函数,是一种函数,主要用来在创建对象时对 对象 进行初始化(即为对象成员变量赋初始值),并且总是与new运算符一起使用. 1.2 new 运算符 new运算符创建一个新 ...
- HDU 1052 Tian Ji -- The Horse Racing【贪心在动态规划中的运用】
算法分析: 这个问题很显然可以转化成一个二分图最佳匹配的问题.把田忌的马放左边,把齐王的马放右边.田忌的马A和齐王的B之间,如果田忌的马胜,则连一条权为200的边:如果平局,则连一条权为0的边:如果输 ...
- ZBrush软件Texture纹理调控板
在zbrush4r8中对一个模型进行纹理制作在速度和易用性方面有诸多优势,通过Texture调控板创建.导入和输出纹理是及其方便且快捷的. Import (导入):导入Photoshop (.psd) ...
- 蓝桥杯_left and throw
思考了许久没有结果,最后,还是一位擅长搜索资源的学长帮我找到了一个不错的代码,这个代码极其精妙,再一次印证了一句话,没有做不到的,只有想不到的,当然这个代码我拿到手的时候是个没有注释的代码,我费尽周折 ...
- Python笔记24-----迭代器、生成器的使用（如嵌套列表的展开、树的遍历等）
1.递归yield使用: 嵌套列表展开 def flatten(nested): if type(nested)==list: for sublist in nested: for i in flat ...
- BZOJ 2150 部落战争 (二分图匹配)
题目大意:给你一个n*m的棋盘,有一些坏点不能走,你有很多军队,每支军队可以像象棋里的马一样移动,不过马是1*2移动的,而军队是r*c移动的,军队只能从上往下移动,如果一个点已经被一直军队经过,那么其 ...
- Postgresql数据库的一些字符串操作函数
今天做项目遇到客户反映了一个麻烦的事情,有一些数据存在,但就是在程序中搜索不出来,后来分析,发现问题为数据前面有几个空白字符,后来用SQL查询了一下,发现八九个数据表中,数千万条数据中有将近三百万条数 ...
- 机器学习关于AUC的理解整理
AUC 几何意义:ROC曲线与X轴的面积 https://blog.csdn.net/luo3300612/article/details/80367901 AUC物理意义:随机给定一个正样本和一个负 ...
- [using_microsoft_infopath_2010]Chapter2 表单需求，使用表决矩阵
本章概要 1.从模板创建表单 2.从创建表单收集需求 3.使用全部表单决策 4.决定需要创建哪种表单
- HDU 4308 Contest 1
纯BFS+优先队列扩展. #include <iostream> #include <cstdio> #include <cstring> #include < ...