3.生产一个消费一个*

Consumer(phone);p.start();c.start();}

}//产品类

true;while(true){synchronized(phone){if(phone.isStore()){//有库存//等待//1.将当前线程记录在对象监视器中(记录当前线程进入到阻塞状态)//2.释放锁资源(解锁)//3.当前线程进入到阻塞状态try

{phone.wait();}

{e.printStackTrace();}}if(flag){phone.setBrand(华为);phone.setPrice(3999);}else{phone.setBrand(小米);phone.setPrice(1999);}flag

!flag;phone.setStore(true);//唤醒唤醒的是对象监视器中随机一个等待的线程唤醒的线程进入到就绪态phone.notify();}}}

}//消费者线程

{while(true){synchronized(phone){if(!phone.isStore()){//没有库存try

{//等待//1.将当前线程记录在对象监视器中(记录当前线程进入到阻塞状态)//2.释放锁资源(解锁)//3.当前线程进入到阻塞状态phone.wait();}

catch

{e.printStackTrace();}}System.out.println(phone.getBrand()

phone.getPrice());phone.setStore(false);//唤醒唤醒的是对象监视器中随机一个等待的线程唤醒的线程进入到就绪态phone.notify();}}}

}1.2,多个生产者多个消费者

1.多个线程(生产者线程、消费者线程)操作同一个资源(产品类的对象)*

2.多个产品之间来回切换(华为

Consumer(phone);p1.start();p2.start();c1.start();c2.start();}

}//生产者线程

true;while(true){synchronized(phone){while(phone.isStore()){//有库存//等待//1.将当前线程记录在对象监视器中(记录当前线程进入到阻塞状态)//2.释放锁资源(解锁)//3.当前线程进入到阻塞状态try

{phone.wait();}

{e.printStackTrace();}}if(flag){phone.setBrand(华为);phone.setPrice(3999);}else{phone.setBrand(小米);phone.setPrice(1999);}flag

!flag;phone.setStore(true);//唤醒唤醒对象监视器中所有的线程phone.notifyAll();}}}

}//产品类

{while(true){synchronized(phone){while(!phone.isStore()){//没有库存try

{//等待//1.将当前线程记录在对象监视器中(记录当前线程进入到阻塞状态)//2.释放锁资源(解锁)//3.当前线程进入到阻塞状态phone.wait();}

catch

{e.printStackTrace();}}System.out.println(phone.getBrand()

phone.getPrice());phone.setStore(false);//唤醒唤醒对象监视器中所有的线程phone.notifyAll();}}}

}区别就是只有一个生产者和消费者的时候不需要一直去判断有没有库存,因为生产了才能消费,消费了才生产

二,仓储模型

StoremaxCapacity、curCapacity、list*

生产者线程

Consumer(store);p.start();c.start();}

}import

{e.printStackTrace();}}list.add(cake);curCapacity;System.out.println(入库当前库存为

curCapacity);this.notify();}//出库public

synchronized

list.removeFirst();curCapacity--;System.out.println(出库当前的库存为

curCapacity

LocalDateTime.now().toString());store.push(cake);}}

}//消费者类

只需把仓库类的出库入库的判断改为while循环即测试类多几个生产,消费线程,其他同上

import

{e.printStackTrace();}}list.add(cake);curCapacity;System.out.println(入库当前库存为

curCapacity);this.notifyAll();}//出库public

synchronized

list.removeFirst();curCapacity--;System.out.println(出库当前的库存为

curCapacity

StoremaxCapacity、curCapacity、list*

生产者线程

Consumer(store);p1.start();p2.start();c1.start();c2.start();}

}三,线程池

{System.out.println(Thread.currentThread().getName()

去执行任务

java.util.concurrent.ExecutorService;

import

java.util.concurrent.Executors;public

class

Executors.newSingleThreadExecutor();for

(int

Task(i);//将任务提交给线程池pool.execute(task);}//关闭线程池pool.shutdown();}

import

java.util.concurrent.ExecutorService;

import

java.util.concurrent.Executors;public

class

Executors.newFixedThreadPool(3);for

(int

Task(i);//将任务提交给线程池pool.execute(task);}//关闭线程池pool.shutdown();}

import

java.util.concurrent.ExecutorService;

import

java.util.concurrent.Executors;public

class

{//创建可缓存的线程池(原本线程池中没有线程有任务就创建线程60秒工作的线程任务是闲置线程就回收)ExecutorService

pool

Executors.newCachedThreadPool();for

(int

Task(i);//将任务提交给线程池pool.execute(task);}//关闭线程池pool.shutdown();}

import

java.util.concurrent.Executors;

import

java.util.concurrent.ScheduledExecutorService;

import

java.util.concurrent.TimeUnit;public

class

{//创建延迟任务的线程池ScheduledExecutorService

pool

Executors.newScheduledThreadPool(3);for

(int

Task(i);//提交任务设置延迟时间pool.schedule(task,

TimeUnit.SECONDS);}//关闭线程池pool.shutdown();}

}四,自定义线程

java.util.concurrent.ArrayBlockingQueue;

import

java.util.concurrent.RejectedExecutionHandler;

import

java.util.concurrent.ThreadFactory;

import

java.util.concurrent.ThreadPoolExecutor;

import

java.util.concurrent.TimeUnit;public

class

num);t.setPriority(Thread.MAX_PRIORITY);num;return

t;}},

{System.out.println(傻逼你提交的任务太快了~~~);}});for

(int

Task(i);//将任务提交给线程池pool.execute(task);}//闲置时间到后会销毁核心线程的方法//注意如果连核心线程都销毁了何谈线程的复用率pool.allowCoreThreadTimeOut(true);pool.shutdown();}

}public

{System.out.println(Thread.currentThread().getName()

去执行任务

java.util.concurrent.ArrayBlockingQueue;

import

java.util.concurrent.TimeUnit;public

class

Task(i);//将任务提交给线程池pool.execute(task);}pool.shutdown();}

}import

java.util.concurrent.BlockingQueue;

import

java.util.concurrent.RejectedExecutionHandler;

import

java.util.concurrent.ThreadFactory;

import

java.util.concurrent.ThreadPoolExecutor;

import

java.util.concurrent.TimeUnit;public

class

MyRejectedExecutionHandler();public

MyThreadPool(int

myRejectedExecutionHandler);}public

MyThreadPool(int

RejectedExecutionHandler{Overridepublic

void

{System.out.println(哎呀你提交的任务太快了~~~);}}//自定义线程工程private

static

num);t.setPriority(Thread.MAX_PRIORITY);num;return

t;}}}五,死锁

1.死锁不会报错程序会一直抢资源2.尽可能不要锁嵌套public

class

{e.printStackTrace();}synchronized

(KuaiZi.b)

{System.out.println(哲学家1吃饭饭);}}}}).start();new

Thread(new

{e.printStackTrace();}synchronized

(KuaiZi.a)

{System.out.println(哲学家2吃饭饭);}}}}).start();}

}class

java.util.concurrent.ArrayBlockingQueue;

import

java.util.concurrent.ExecutionException;

import

com.qf.thread_pool_03.MyThreadPool;public

class

需求计算任务一个包含了2万个整数的数组分拆了多个线程来进行并行计算最后汇总出计算的结果。

*

*/public

ArrayBlockingQueue(30));//创建任务Task

task1

20000);//提交任务返回Future任务的返回值就在Future里FutureInteger

future1

pool.submit(task1);FutureInteger

future2

pool.submit(task2);FutureInteger

future3

pool.submit(task3);FutureInteger

future4

pool.submit(task4);//合并计算System.out.println(future1.get()

future2.get()

future4.get());pool.shutdown();}

}import

java.util.concurrent.Callable;//带有返回值的任务类

public