死锁,线程协作(同步,阻塞队列,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从阻塞队列取出元素[消费者] 当队列空时,获取元素的操作会被阻塞 当队列满时,添加元素的操作会被阻塞 阻塞队列的优势:在多线程领域,发生阻塞时,线程 ...
随机推荐
- Android 自定义简单控件--星级评价
效果图 实现 package com.easypass.carstong.view; import android.content.Context; import android.content.re ...
- hdu 1754 I Hate It【线段树】
维护一个最大值 #include<cstdio> #include<cstring> #include<iostream> #include<algorith ...
- XP访问WIN10共享打印机提示错误:操作无法完成,拒绝访问
XP系统添加打印机--连接到此计算机的本地打印机(取消自动检测)--创建新端口(LOCAL port)----输入端口名\\计算机名\打印机名.(例如:\\adubei\\HP lasjet 1020 ...
- 在ros中集成Fast-rtps库并运行hello world 程序
1.介绍 ROS:自行百度 Fast-RTPS:是eProsima公司对RTPS标准的一个实现,也就是函数库.RTPS是DDS标准中的一个子集.RTPS:Real Time Publish Subsc ...
- js在当前日期基础上,加1天 3天 7天 15天
需求 点击保障期的天数 根据起始时间算出结束时间 代码 //点击保障期触发的方法 periodChange(val,id){ this.activeNumperiod=val this.submitD ...
- CentOS 7.5安装pycharm
环境 安装环境: windows 10 Pro CentOS Linux release 7.6.1810 (Core) VMWare Workstation 15 Pro 安装图形化界面包 首先更新 ...
- [LUOGU]P3701 主席树(假的)
有人恶意刷难度...就一个最大流模板... 但是题面吼啊2333 #include <iostream> #include <cstdio> #include <queu ...
- 2019-03-15 使用Request POST获取CNABS网站上JSON格式的表格数据,并解析出来用xlwt写到Excel中
import requests import xlwt url = 'https://v1.cn-abs.com/ajax/ChartMarketHandler.ashx' headers={ 'Us ...
- vue生命周期的基础部分
Vue实例从创建到销毁的过程,就是生命周期. Vue的生命周期包括:开始创建.初始化数据.编译模板.挂载Dom.渲染→更新→渲染.卸载等一系列过程. 在Vue的整个生命周期中,提供了一系列的事件,可以 ...
- php 魔术方法和魔术常量
魔术方法:PHP把类中所有以__(两个下划线)开头的方法当成魔术方法,一般建议用户不要将自定义的方法前面加上__作为前缀.魔术方法: 1. __construct() 类的默认构造方法,如果__con ...