一、线程安全
线程安全的问题，是针对多线程的程序。单线程的情况下，是不存在线程安全问题。
产生线程安全问题的原因：多个线程同时访问同一块代码。但是实际上我们希望该代码块是原子性的，在某一个时间点，只希望一个线程单独访问，不希望多个线程同时访问。
解决方案：
1：同步代码块。
synchronized (this) {
//被同步的代码块；
}
synchronized(同步监视器对象) ：java 关键字
{}:同步代码块：希望在某一个时间点只有一个线程访问的代码块。
执行过程：
1：线程1 执行到了同步代码块。要对同步监视器进行检测，看是否被其他的线程上锁了。发现没有上锁，那么线程1对同步监视器对象 上锁，并开始访问 同步代码块。
2：线程2 执行到了同步代码块，检测同步监视器，发现监视器已经被 线程1 上锁了。就进入就绪状态，等待cpu 下次调度执行。
3：线程1 执行完毕同步代码块，然后对 同步监视器对象 解锁。并执行后续的代码。
4：当 线程2 被再次调度执行的时候，发现同步监视器对象已经被解锁，那么就对同步监视器对象 加锁 并访问 同步代码块。
类似于上厕所：没人（有人就等着），进去，锁门，方便，然后冲水开门出去。下一个。
2：同步方法：
相当于把整个方法体都同步了。
同步监视器对象是this(实例方法)。
同步方法，会导致在任意时刻，只能有一个线程访问该方法。一个线程执行完毕方法之后，其他的线程才能访问。
同步块和同步方法都会导致程序的效率降低。多了检测监视器对象是否加锁，加锁和解锁的过程。
3：如果同步方法是静态方法，那么同步监视器对象是当前类的大 Class 对象。
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 模拟两个人取钱，说明线程安全的问题。
* 张三和 张三媳妇，一起去取钱。
* 一个在ATM
* 一个在柜台。
* 一共1500
* 每个人都想取1000块钱。
*
*/
public class AccountTest {
public static void main(String[] args) {
PersonRunnable runnable = new PersonRunnable();
Thread zhangSan = new Thread(runnable, "张三");
Thread zhangSanXiFu = new Thread(runnable, "张三媳妇");
zhangSan.start();
zhangSanXiFu.start();
}
}
/**
* 账户类
*
*/
class Account{
private int money = 1500;
//第三种线程同步的实现 jdk1.5出现的。
private Lock lock = new ReentrantLock();
/**
* 取现
* @param money 取钱的钱数
* @return 如果取钱成功，返回 true ，否则返回 false。
*/
public /*synchronized*/ boolean withDrawMoney(int money) {
//同步代码块
//synchronized (this) {
//在try 外面将 需要同步的代码锁住，然后将需要同步的代码，放到try 块中。
lock.lock();
try {
if(this.money >= money){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.money -= money;
System.out.println(Thread.currentThread().getName() + "--> 取钱[成功]。余额为："+this.money);
return true;
}
}finally{
//必须执行
lock.unlock();
}
// }
System.out.println(Thread.currentThread().getName() + "--> 取钱[失败]。余额为："+this.money);
return false;
}
}
class PersonRunnable implements Runnable{
//唯一的账户
private Account account = new Account();
public void run() {
account.withDrawMoney(1000);
}
}
二、关于监视器的选择
如果想实现线程间的互斥访问同步代码块，那么监视器对象必须唯一。只有一个实例存在。
1：this：保证只有一个this。这个对象只被实例化了一次。
2：final static Object obj = new Object();
3: 当一个类加载的时候，类加载只有一次，会产生2部分内容。1部分是类的字节码元数据（方法区）。还会生成一个对象（堆区）。对象的类型是 描述类的类型 Class。
这个大Class 类型的对象也是唯一的。可以通过 类名.class 来得到这个唯一的描述当前类的对象。
好处：不可变以及唯一性。
当前类的大Class 对象。
/**
* 继承线程Thread 类，来模拟火车站售票。
* 每一个售票窗口都代表了一个线程。
* 所有的售票员，都访问同一个售票系统。
*
*/
public class TestTicket {
public static void main(String[] args) {
TicketSystem system = new TicketSystem();
Saler saler1 = new Saler(system);
saler1.setName("售票员小姐姐-1");//设置线程的名字
Saler saler2 = new Saler(system);
saler2.setName("售票员小姐姐-2");//设置线程的名字
Saler saler3 = new Saler(system);
saler3.setName("售票员小姐姐-3");//设置线程的名字
Saler saler4 = new Saler(system);
saler4.setName("售票员小姐姐-4");//设置线程的名字
Saler saler5 = new Saler(system);
saler5.setName("售票员小姐姐-5");//设置线程的名字
saler1.start();
saler2.start();
saler3.start();
saler4.start();
saler5.start();
}
}
//售票系统
class TicketSystem{
//剩余票数
private int count = 100;
// static Object o = new Object();
/**
* @param count 本次卖票的张数
* @return 是否售票成功
*/
public /*synchronized*/ boolean sale(int count){
//使用当前类的 大 Class 对象 作为 监视器。具有不可变和唯一的特性。
synchronized (TicketSystem.class) {
if(this.count >= count){
this.count -= count;
System.out.println(Thread.currentThread().getName() + " 卖出了 "+count+" 张票，剩余票数为："+this.count);
//让当前线程等待一下下 100
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
return true;
}
}
//
System.out.println(Thread.currentThread().getName() + " 售票失败 ，余票不足 ，剩余票数为："+this.count);
return false;
}
}
//售票员
class Saler extends Thread{
//售票员需要访问唯一的票务系统
//多个线程对象，访问同一个对象的数据，可以使用同时持有唯一对象引用的方法。
private TicketSystem system;
public Saler(TicketSystem system) {
this.system = system;
}
//线程任务的主体部分。
public void run() {
boolean result = system.sale(1);
while(result){
result = system.sale(1);
}
}
}
三、单例模式最终版
public class SingleTonTest {
static int num = 0;
public static void main(String[] args) {
//在线程1 中 得到唯一的实例。
new Thread(){
@Override
public void run() {
MySingleton singleton1 = MySingleton.getInstance();
System.out.println(singleton1);
}
}.start();
//在线程2中再得到一次
new Thread(){
@Override
public void run() {
MySingleton singleton2 = MySingleton.getInstance();
System.out.println(singleton2);
}
}.start();
//使用Runnable 接口，匿名内部类
new Thread(new Runnable() {
@Override
public void run() {
}
}).start();
//面试题
new Thread(new Runnable() {// 11111
@Override
public void run() {
System.out.println(22222);
}
}){
public void run() {
System.out.println(11111);
};
}.start();
}
}
//懒汉模式单例类
class MySingleton{
private int num = 10;
private static MySingleton singleton;
private MySingleton(){}
//对外的提供的唯一的 方位 唯一实例的方法
public /*synchronized*/ static MySingleton getInstance(){
//为了提高效率，后续的该方法的访问都不会再进行 加锁和解锁的 和监视器是否有锁的判断
if(singleton == null){
synchronized (MySingleton.class) {
//为了保证唯一的实例
if(singleton == null){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
singleton = new MySingleton();
}
}
}
return singleton;
}
public void setNum(int num){
this.num = num;
}
public int getNum(){
return num;
}
}
四、线程死锁
线程死锁：DeadLock。两个进程相互上锁，当两个进程同时被锁住的时候，程序将无法继续向下执行，此时即为死锁。
static Object o1 = new Object()
static Object o2 = new Object();
//线程-1 执行的代码
synchronized(o1){
// thread-1 stop here
synchronized(o2){
}
}
//线程-2 执行 代码
synchronized(o2){
// thread-2 stop here
synchronized(o1){
}
}
出现死锁的条件：
1：同步代码块嵌套。
2：多个线程之间已经锁住的资源为彼此请求锁住的资源。
如果死锁已经产生，那么没有办法解决，只能在编码的时候避免出现死锁。
避免死锁：避免出现嵌套的同步代码块。
public class DeadLockTest {
public static void main(String[] args) {
new DeadLockThread(0).start();
new DeadLockThread(1).start();
}
}
class DeadLockThread extends Thread{
//两个监视器对象
final static Object O1 = new Object();
final static Object O2 = new Object();
private int id;
public DeadLockThread(int id) {
this.id = id;
}
@Override
public void run() {
if(id == 0){
synchronized (O1) {
System.out.println(Thread.currentThread().getName()+"--O1-->O2");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (O2) {
System.out.println(Thread.currentThread().getName()+"--O1-->O2--------");
}
}
}else{
synchronized (O2) {
System.out.println(Thread.currentThread().getName()+"--O2-->O1");
synchronized (O1) {
System.out.println(Thread.currentThread().getName()+"--O2-->O1--------");
}
}
}
}
}
五、线程间通信-管道流
使用管道流实现多个线程之间的信息的交互。
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
/**
* 两个线程 独立的 类，进行信息的交互
* 管道输出流写出的数据，被管道输入流读取到。
* 在一个线程中用管道输出流写出数据。
* 在另外一个线程中使用管道输入流读取 管道输出流写出的数据
*
*/
public class PipedStreamTest {
public static void main(String[] args) throws Exception {
PipedInputStream pis = new PipedInputStream();
PipedOutputStream pos = new PipedOutputStream();
//可以通过构造方法将管道输入输出流建立关联，也可以通过方法。
pis.connect(pos);
PipedOutputStreamThread thread1 = new PipedOutputStreamThread(pos);
PipedInputStreamThread thread2 = new PipedInputStreamThread(pis);
new Thread(){
public void run() {
thread2.start();
};
}.start();
Thread.sleep(5000);
new Thread(){
public void run() {
thread1.start();
};
}.start();
}
}
//管道输出流的线程类
class PipedOutputStreamThread extends Thread{
//持有管道输出流的引用。
private PipedOutputStream pos;
public PipedOutputStreamThread(PipedOutputStream pos) {
this.pos = pos;
}
public void run() {
try {
//使用管道输出流写出数据
String str = "多年不见，你还好么？";
// byte[] bs = str.getBytes();
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(pos));
bw.write(str);
// pos.write(bs);
bw.newLine();
bw.flush();
bw.close();
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
pos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//用于读取管道输出流写出数据的输入流
class PipedInputStreamThread extends Thread{
private PipedInputStream pis;
public PipedInputStreamThread(PipedInputStream pis) {
this.pis = pis;
}
@Override
public void run() {
try {
BufferedReader br = new BufferedReader(new InputStreamReader(pis));
String str = br.readLine();
System.out.println("接收到的内容为："+str);
br.close();
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
pis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
六、生产者消费者典型案例
都是Object类的方法。
Object obj = new Object();
obj .wait():让当前线程在当前对象上等待。 让执行这句代码的线程在obj上等待。
obj .notify(): 将在obj 对象上等待的某个线程唤醒。
obj .notifyAll(): 将在obj 对象上等待的所有的线程唤醒。
这三个方法使用的环境：必须让当前线程持有当前对象监视器的锁。
obj .wait() 表示 当前线程必须对 obj 上锁了。
import java.util.Arrays;
/**
* 自定义容器 模拟栈
* 底层使用数组来实现。Object
*
*/
public class MyStack {
//定义栈的初始化容量
public static final int INIT_CAPACITY = 1;
//栈顶指针 所有对元素的操作都是 通过栈顶指针来完成的。
private int index;
//存放元素数组
private Object[] elementData;
public MyStack() {
elementData = new Object[INIT_CAPACITY];
index = 0;
}
/**
* 将 e 压入栈顶
* @param e
*/
public void push(E e){
synchronized (this) {
if(isFull()){
//如果栈已满
//让生产者线程在 当前容器上等待。当前线程进入阻塞状态。并对当前对象解锁。
try {
this.wait();
} catch (InterruptedException e1) {
e1.printStackTrace();
}
}
try {
Thread.sleep(300);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
//生产者顺利的生产了一个面包
elementData[index++] = e;
System.out.println(Thread.currentThread().getName()+"--生产了一个："+e);
//TODO 通知消费者你可以继续消费了
//生产者线程通知消费者线程可以继续消费了，消费者线程如果处于阻塞状态，那么消费者线程从阻塞状态进入 就绪状态，等待cpu 的下次的调度执行。
this.notify();
}
}
/**
* 弹栈操作
* @return
*/
public synchronized void pop() {
if(isEmpty()){
//消费者线程，发现容器空了，那么就在容器上等待。导致消费者线程进入阻塞状态，并释放对 this 的锁
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
Thread.sleep(300);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
//先指针下移
index --;
E e = (E)elementData[index];
elementData[index] = null;
System.out.println(Thread.currentThread().getName() + "--消费了："+e);
//如果生产者线程此刻处于阻塞状态。那么会让生产者线程从阻塞状态进入就绪状态，等待cpu 的下次调度，如果被调度执行，那么生产者从上次等待的位置继续执行。
//消费者线程通知在 this 上等待的生产者线程，可以继续生产了。
this.notify();
}
/**
* 获取栈顶元素，但是不删除
* @return
*/
public E peek()throws Exception{
if(isEmpty()){
Exception e = new Exception("囊中羞涩，别摸了！");
throw e;
}else{
return (E)elementData[index-1];
}
}
/**
* 容器中是否包含 e
* @param e
* @return
*/
public boolean search(E e){
if(isEmpty())
return false;
//如果 e 是 null 判断 elementData 是否有null
if(e == null){
for(int i=0;i
if(elementData[i] == null)
return true;
}
}else{//e 不是null
for(int i=0;i
if(e.equals(elementData[i]))
return true;
}
}
return false;
}
/**
* 判断栈是否满了
* @return
*/
private boolean isFull(){
return index == elementData.length;
}
/**
* 栈是否为空
* @return
*/
public boolean isEmpty(){
return index == 0;
}
/**
* 得到元素的个数
* @return
*/
public int size(){
return index;
}
/**
* 容量
* @return
*/
public int capacity(){
return elementData.length;
}
@Override
public String toString() {
return Arrays.toString(Arrays.copyOf(elementData, index));
}
}
public class PCTest {
public static void main(String[] args) {
MyStack stack = new MyStack<>();
Producer producer = new Producer(stack);
producer.setName("巴莉甜甜");
Consumer consumer = new Consumer(stack);
consumer.setName("YiBao");
producer.start();
consumer.start();
}
}
/**
* 消费者线程 ，消费面包
*
*/
public class Consumer extends Thread{
private MyStack stack;
Consumer(MyStack stack) {
super();
this.stack = stack;
}
@Override
public void run() {
for(int i=0;i<10;i++){
stack.pop();
}
}
}
/**
* 面包类
*
*/
public class Bread {
private int id;
Bread(int id) {
super();
this.id = id;
}
@Override
public String toString() {
return "面包 [id=" + id + "]";
}
}
/**
* 生产者线程
*
*/
public class Producer extends Thread{
private MyStack stack;
Producer(MyStack stack) {
super();
this.stack = stack;
}
//生产十个面包
public void run() {
for(int i=0;i<10;i++){
stack.push(new Bread(i));
}
}
}
七、多个消费者生产者出现的问题
1：消费者1 开始消费，等待了。
2：消费者2 开始消费，等待了。
3：生产者 生产了一个馒头，唤醒了 消费者1. 生产者继续生产，等待了。
4：消费者1 开始消费，结果把消费者2 唤醒了。消费者1 等待了。
5：消费者2 开始消费，容器已经是空的了。 数组下标越界。
解决：
import java.util.Arrays;
/**
* 自定义容器 模拟栈
* 底层使用数组来实现。Object
*
*/
public class MyStack {
//定义栈的初始化容量
public static final int INIT_CAPACITY = 1;
//栈顶指针 所有对元素的操作都是 通过栈顶指针来完成的。
private int index;
//存放元素数组
private Object[] elementData;
public MyStack() {
elementData = new Object[INIT_CAPACITY];
index = 0;
}
//让生产者线程在o1上等待。 在o2上唤醒。
static Object o1 = new Object();
//让消费者线程在o2 上等待。在o1上唤醒。
static Object o2 = new Object();
/**
* 将 e 压入栈顶
* @param e
*/
public void push(E e){
synchronized (o1) {
while(isFull()){//如果栈已满
//让生产者线程在 当前容器上等待。当前线程进入阻塞状态。并对当前对象解锁。
try {
o1.wait();
} catch (InterruptedException e1) {
e1.printStackTrace();
}
}
// try {
// Thread.sleep(300);
// } catch (InterruptedException e1) {
// e1.printStackTrace();
// }
//生产者顺利的生产了一个面包
elementData[index++] = e;
System.out.println(Thread.currentThread().getName()+"--生产了一个："+e);
//TODO 通知消费者你可以继续消费了
//生产者线程通知消费者线程可以继续消费了，消费者线程如果处于阻塞状态，那么消费者线程从阻塞状态进入 就绪状态，等待cpu 的下次的调度执行。
// this.notifyAll();
synchronized (o2) {
o2.notify();
}
}
}
/**
* 弹栈操作
* @return
*/
public /*synchronized */void pop() {
synchronized (o2) {
while(isEmpty()){
//消费者线程，发现容器空了，那么就在容器上等待。导致消费者线程进入阻塞状态，并释放对 this 的锁
try {
o2.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// try {
// Thread.sleep(300);
// } catch (InterruptedException e1) {
// e1.printStackTrace();
// }
//先指针下移
index --;
E e = (E)elementData[index];
elementData[index] = null;
System.out.println(Thread.currentThread().getName() + "--消费了："+e);
//如果生产者线程此刻处于阻塞状态。那么会让生产者线程从阻塞状态进入就绪状态，等待cpu 的下次调度，如果被调度执行，那么生产者从上次等待的位置继续执行。
//消费者线程通知在 this 上等待的生产者线程，可以继续生产了。
// this.notifyAll();
synchronized (o1) {
o1.notify();
}
}
}
/**
* 获取栈顶元素，但是不删除
* @return
*/
public E peek()throws Exception{
if(isEmpty()){
Exception e = new Exception("囊中羞涩，别摸了！");
throw e;
}else{
return (E)elementData[index-1];
}
}
/**
* 容器中是否包含 e
* @param e
* @return
*/
public boolean search(E e){
if(isEmpty())
return false;
//如果 e 是 null 判断 elementData 是否有null
if(e == null){
for(int i=0;i
if(elementData[i] == null)
return true;
}
}else{//e 不是null
for(int i=0;i
if(e.equals(elementData[i]))
return true;
}
}
return false;
}
/**
* 判断栈是否满了
* @return
*/
private boolean isFull(){
return index == elementData.length;
}
/**
* 栈是否为空
* @return
*/
public boolean isEmpty(){
return index == 0;
}
/**
* 得到元素的个数
* @return
*/
public int size(){
return index;
}
/**
* 容量
* @return
*/
public int capacity(){
return elementData.length;
}
@Override
public String toString() {
return Arrays.toString(Arrays.copyOf(elementData, index));
}
}
八、jdk1.5的针对同步嵌套的解决
import java.util.Arrays;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 自定义容器 模拟栈
* 底层使用数组来实现。Object
*
*/
public class MyStack {
//定义栈的初始化容量
public static final int INIT_CAPACITY = 2;
//栈顶指针 所有对元素的操作都是 通过栈顶指针来完成的。
private int index;
//存放元素数组
private Object[] elementData;
public MyStack() {
elementData = new Object[INIT_CAPACITY];
index = 0;
}
//使用jdk1.5 的针对线程死锁的解决方案。
private Lock lock = new ReentrantLock();
//需要两个Condition 对象。
//生产者的Condition
private Condition proCon = lock.newCondition();
//消费者的Condition
private Condition conCon = lock.newCondition();
/**
* 将 e 压入栈顶
* @param e
*/
public void push(E e){
lock.lock();
try {
while(isFull()){//如果栈已满
//让生产者线程在 当前容器上等待。当前线程进入阻塞状态。并对当前对象解锁。
try {
// o1.wait();
proCon.await();
} catch (InterruptedException e1) {
e1.printStackTrace();
}
}
//生产者顺利的生产了一个面包
elementData[index++] = e;
System.out.println(Thread.currentThread().getName()+"--生产了一个："+e);
//TODO 通知消费者你可以继续消费了
//生产者线程通知消费者线程可以继续消费了，消费者线程如果处于阻塞状态，那么消费者线程从阻塞状态进入 就绪状态，等待cpu 的下次的调度执行。
// this.notifyAll();
// o2.notify();
conCon.signal();
} finally {
lock.unlock();
}
}
/**
* 弹栈操作
* @return
*/
public /*synchronized */void pop() {
lock.lock();
try {
while(isEmpty()){
//消费者线程，发现容器空了，那么就在容器上等待。导致消费者线程进入阻塞状态，并释放对 this 的锁
try {
// o2.wait();
conCon.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//先指针下移
index --;
E e = (E)elementData[index];
elementData[index] = null;
System.out.println(Thread.currentThread().getName() + "--消费了："+e);
//如果生产者线程此刻处于阻塞状态。那么会让生产者线程从阻塞状态进入就绪状态，等待cpu 的下次调度，如果被调度执行，那么生产者从上次等待的位置继续执行。
//消费者线程通知在 this 上等待的生产者线程，可以继续生产了。
// this.notifyAll();
// o1.notify();
proCon.signal();
} finally {
lock.unlock();
}
}
/**
* 获取栈顶元素，但是不删除
* @return
*/
public E peek()throws Exception{
if(isEmpty()){
Exception e = new Exception("囊中羞涩，别摸了！");
throw e;
}else{
return (E)elementData[index-1];
}
}
/**
* 容器中是否包含 e
* @param e
* @return
*/
public boolean search(E e){
if(isEmpty())
return false;
//如果 e 是 null 判断 elementData 是否有null
if(e == null){
for(int i=0;i
if(elementData[i] == null)
return true;
}
}else{//e 不是null
for(int i=0;i
if(e.equals(elementData[i]))
return true;
}
}
return false;
}
/**
* 判断栈是否满了
* @return
*/
private boolean isFull(){
return index == elementData.length;
}
/**
* 栈是否为空
* @return
*/
public boolean isEmpty(){
return index == 0;
}
/**
* 得到元素的个数
* @return
*/
public int size(){
return index;
}
/**
* 容量
* @return
*/
public int capacity(){
return elementData.length;
}
@Override
public String toString() {
return Arrays.toString(Arrays.copyOf(elementData, index));
}
}
