标签：方法 缓冲区 ref object类 拒绝 shu 数据 用法 另一个
目录
wait 和 notify 的调用必须是同一个对象调用。谁让他等待了，谁才能让他唤醒。解铃还须系铃人。
多个线程同时访问一个资源
多个线程的执行是抢占式的，当一个线程执行方法时，可能会被另一个线程抢占CPU，当前线程的操作不能完整的执行，导致数据出现问题。
public void transfer(int from,int to,int money){
//一个线程扣除一个账户一定金额，准备给另一个账户加钱
//被其他线程抢占CPU执行，其他线程执行完转账后，前面线程扣的钱还没有加
//统计钱总数就出现问题
accounts[from] -= money;
System.out.println("从"+from+"转到"+to+"账户"+money);
accounts[to] += money;
System.out.println("银行的总账是：" + sum());
}让一个线程能完整的执行完任务后，另一个线程再执行
上锁机制：
1. 同步代码块
2. 同步方法
3. 同步锁
可以对一段代码上锁
synchronized(锁对象){
需要上锁的代码
}任意的成员变量对象都可以作为锁，因为在Object类中定义了锁的方法。对象必须是成员对象
public void transfer(int from,int to,int money){
synchronized (lock) {
accounts[from] -= money;
System.out.println("从"+from+"转到"+to+"账户"+money);
accounts[to] += money;
System.out.println("银行的总账是：" + sum());
}
}当一个线程进入同步块后，JVM启动一个Monitor（监视器）对同步块进行监控，如果另一个线程想进入这个同步块，监视器会拒绝，当前面线程执行完代码，释放锁后，监视器才会让其他线程进入。锁普通方法可以锁对象，锁静态方法要锁类
public static void transfer(int from,int to,int money){
synchronized (本类.class) {
accounts[from] -= money;
System.out.println("从"+from+"转到"+to+"账户"+money);
accounts[to] += money;
System.out.println("银行的总账是：" + sum());
}
}
public synchronized 返回值 方法名(参数){
代码
}1）锁的粒度不同
同步块粒度小，可以只锁一段代码
同步方法粒度大，锁的是整个方法
2）锁对象不同
同步块任意成员对象都可以作为锁
同步方法锁对象是thisjdk1.5出现的，类似同步块，但性能更高，功能更强。
实现类：
ReadLock 读锁
WriteLock 写锁
ReadWriteLock 读写锁
ReentrantLock 重入锁1）创建ReentrantLock 的成员变量
Lock必须是成员变量才行，局部变量还是其他的都不行
2）上锁 ，调用lock()
3）释放锁，调用unlock()，注意unlock必须执行，否则就会死锁
锁.lock();
try{
需要上锁代码
}finally{
锁.unlock();
}
同步锁 > 同步代码块 > 同步方法
锁机制会提高多线程情况下数据安全性，但是会降低程序的性能
1）使用同步锁之后没有手动释放锁
2）两个线程互相合并对方
3）两个线程都需要对方的锁，又都持有对方的锁
两个方法、两个锁、两个同步块相互嵌套、两个线程
锁1
锁2
方法1(){
sync(锁1){
....
sync(锁2){
}
}
}
方法2(){
sync(锁2){
....
sync(锁1){
}
}
}Object类的方法：
void wait() 让当前线程进入等待状态
void wait(long time) 让当前线程等待一定时间，时间过后线程恢复执行void notify() 通知等待的其中一个线程，让其恢复执行
void notifyAll() 通知所有等待的线程1）上面的四个方法必须是锁对象，如果不是就会抛出异常IllegalMonitorStateException。
2）通知线程的锁对象，必须是让线程进行等待的锁对象线程执行到同步块或同步方法时，监视器会对线程进行监视，当调用wait或notify时，JVM会检查调用方法的对象是否是同步块或方法的锁对象，如果不是就抛出异常。1）wait时线程会释放锁，sleep时线程不会释放锁
2）调用方式：wait可以由任意锁对象，sleep是通过Thread类调用
3）wait可以不设置时间，sleep必须设置睡眠时间
4）wait可以被通知，sleep必须等睡眠时间结束不是GOF23模式之一，是和线程相关的模式
在线程世界中生产和消费的是数据，有些线程用于生产数据就是生产者，有些线程用于使用数据就是消费者，生产者生产数据的速度和消费者消费数据的速度会出现不一致，生产者的速度过快会浪费系统资源，消费者速度过快会浪费系统资源和用户时间，生产者和消费者模式主要用于协调生产者线程和消费者线程的速度。1）缓冲区
2）线程
3）等待
4）通知首先会建立缓冲区用于存放数据，生产者线程生产的数据会放入缓冲区，如果缓冲区满了，就让生产者线程等待，通知所有消费者线程来消费，如果缓冲区空了，就让消费者线程等待，通知所有生产者来生产。/**
* 包子类
* @author Administrator
*
*/
public class Baozi {
private int id;
public Baozi(int id) {
this.id = id;
}
@Override
public String toString() {
return "Baozi [id=" + id + "]";
}
}
---------------------------------------------------
/**
* 包子仓库
* @author Administrator
*
*/
public class BaoziStore {
//缓冲区上限
private static final int MAX_COUNT = 50;
//包子缓冲区
private List<Baozi> baozis = new ArrayList<>();
//做包子
public synchronized void makeBaozi(){
//如果缓冲区满了，就让生产者线程等待
if(baozis.size() == MAX_COUNT){
System.out.println("仓库满了，生产者等待");
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
//如果缓冲区没满，通知生产者继续做包子，以及消费者来吃包子
this.notifyAll();
}
//创建包子，保存到缓冲区
Baozi baozi = new Baozi(baozis.size() + 1);
System.out.println("生产者做了"+baozi);
baozis.add(baozi);
}
//拿包子
public synchronized void takeBaozi(){
//如果缓冲区空了，就让消费者线程等待
if(baozis.size() == 0){
System.out.println("仓库空了，消费者等待" + Thread.currentThread().getName());
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
//如果缓冲区没满，通知生产者继续做包子，以及消费者来吃包子
this.notifyAll();
}
//从缓冲区删除一个包子
if(baozis.size() > 0){
Baozi baozi = baozis.remove(baozis.size() - 1);
System.out.println(Thread.currentThread().getName()+"吃了"+baozi);
}
}
}
----------------------------------------------------------
public class BaoziTest {
public static void main(String[] args) {
//创建包子仓库
BaoziStore store = new BaoziStore();
//创建生产者线程生产100个包子
new Thread(()->{
for(int i = 0;i < 100;i++){
store.makeBaozi();
}
}).start();
//创建100个消费者线程吃1个包子
for(int i = 0;i < 100;i++){
new Thread(()->{
store.takeBaozi();
}).start();
}
}
}
线程是一种系统级的资源，创建和销毁是需要消耗系统资源的，如果大量使用线程，推荐使用线程池，线程池能够对线程进行回收利用，从而节约系统资源。
一般的线程执行完后，就进入死亡状态，被回收；在线程池中的线程执行完任务后，会进入等待状态，直到有新的任务，再通知线程执行。execute(Runnable runnable) 在线程池中获得线程执行任务shutdown() 停止，等待所有线程执行完
shutdownNow() 停止，强制停止所有线程帮助创建各种线程池
newCachedThreadPool() 创建长度不限的线程池
newFixedThreadPool(int size)创建长度固定的线程池
size是线程的最大数量
前两种的区别：
长度不限的线程池，可能在并发量大的情况下创建很多线程，对系统的压力比较大；长度有限的线程池，可以控制并发量
size 线程数量应该是CPU的核心数 * N （N大于等于1取决于任务执行时间和并发量）
内核数：Runtime.getRuntime().availableProcessors()
newSingleThreadExecutor() 创建单一线程池1）使用继承Thread、Runnable和各种线程池启动线程
2）编写线程安全的单例模式
3）使用生产者消费者模拟12306网站，4个服务器每个提供50张票，100个消费者每人买两张票
4）自学：使用阻塞队列实现生产者消费者模式标签：方法 缓冲区 ref object类 拒绝 shu 数据 用法 另一个
原文地址：https://www.cnblogs.com/macht/p/11640880.html
