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