java基础，线程 - 黑马程序员技术交流社区

class ProducerConsumerDemo
{
public static void main(String[] args)
{
Resource r = new Resource();
Producer pro = new Producer(r);
Consumer con = new Consumer(r);
Thread t1 = new Thread(pro);
Thread t2 = new Thread(pro);
Thread t3 = new Thread(con);
Thread t4 = new Thread(con);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
/*
对于多个生产者和消费者。
为什么要定义while判断标记。
原因：让被唤醒的线程再一次判断标记。
为什么定义notifyAll，
因为需要唤醒对方线程。
因为只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。
*/
class Resource
{
private String name;
private int count = 1;
private boolean flag = false;
// t1 t2
public synchronized void set(String name)
{
while(flag)
try{this.wait();}catch(Exception e){}//t1(放弃资格) t2(获取资格)
this.name = name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
flag = true;
this.notifyAll();
}
// t3 t4
public synchronized void out()
{
while(!flag)
try{wait();}catch(Exception e){}//t3(放弃资格) t4(放弃资格)
System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
flag = false;
this.notifyAll();
}
}
class Producer implements Runnable
{
private Resource res;
Producer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
res.set("+商品+");
}
}
}
class Consumer implements Runnable
{
private Resource res;
Consumer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
res.out();
}
}
}

复制代码

//共享的资源类
class Resource {
private String name;
private int count = 1;
// 当flag标记为真(有货)时，执行负责消费的同步代码块，当flag标记为假(无货)时，执行负责生产的同步代码块
private boolean flag = false;
//负责生产的同步代码块
public synchronized void set(String name) {
while (flag)
try {
this.wait(); // 先判断flag，如果不满足，此线程要进入等待状态；若满足继续向下执行
} catch (InterruptedException e) {
}
this.name = name + count;
count++;
System.out.println(Thread.currentThread().getName() + "....生产者..."
+ this.name);
flag = true; // 生产完之后，就有存货了，flag修改为真
notify(); // 唤醒其它的线程
}
//负责消费的同步代码块
public synchronized void out() {
while (!flag)
try {
this.wait(); // 先判断flag，如果不满足，此线程要进入等待状态；若满足继续向下执行
} catch (InterruptedException e) {
}
System.out.println(Thread.currentThread().getName()
+ "....消费者............." + this.name);
flag = false; // 消费完之后，就没有存货了，flag修改为假
notify(); // 唤醒其它的线程
}
}
//生产者类，实现Runnable接口，覆盖run()方法
class Producer implements Runnable {
private Resource r;
Producer(Resource r) {
this.r = r;
}
public void run() {
while (true) {
r.set("烤羊肉串");
}
}
}
//消费者类，实现Runnable接口，覆盖run()方法
class Consumer implements Runnable {
private Resource r;
Consumer(Resource r) {
this.r = r;
}
public void run() {
while (true) {
r.out();
}
}
}
//演示类
class MyProducerConsumer {
public static void main(String[] args) {
Resource r = new Resource();
Producer pro = new Producer(r);
Consumer con = new Consumer(r);
// 我们自己一共新建两个线程，一个负责生产，一个负责消费
Thread t1 = new Thread(pro);
Thread t2 = new Thread(con);
t1.start();
t2.start();
}
}

复制代码

this.notifyAll();

复制代码

/*
需求：写出一个多线程生产者消费程序
思路，生产者和消费者共同处理一堆资源
生产者和消费者由多个线程处理
*/
class Res
{
private String name;
private boolean kai=false;
private int count=1;
public synchronized void setName(String name)
{
while (kai)
try{this.wait();}catch(Exception e){}
this.name = name+count++;//先进行初始化，把商品的名字和编号进行初始化
System.out.println(Thread.currentThread().getName()+"-----商品已经生产------"+this.name);//为了直观，把初始化的结果打印到控制台
kai = true;
this.notifyAll();
}
public synchronized void out()
{
while(!kai)
try{this.wait();}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"----商品已售出---"+this.name);//把销售的结果打印出控制台
kai = false;
this.notifyAll();
}
}
class Producer implements Runnable
{
private Res r;
Producer(Res r)//将资源传递给生产者，并进行赋值打印处理
{
this.r = r;
}
public void run()
{
while (true)//因为要打印多次，并且不知道打印次数，所以用while
{
r.setName("商品");
}
}
}
class Consumer implements Runnable
{
private Res r;
Consumer(Res r)//把资源传递给消费者，并进行输出处理
{
this.r = r;
}
public void run()
{
while (true)
{
r.out();
}
}
}
class h
{
public static void main(String[] args)
{
Res r = new Res();
Producer pro = new Producer(r);
Consumer con = new Consumer(r);
Thread t1 = new Thread(pro);
Thread t2 = new Thread(pro);
Thread t3 = new Thread(con);
Thread t4 = new Thread(con);
t1.start();
t2.start();
t3.start();
t4.start();
}
}

复制代码

/*
需求：写出一个多线程生产者消费程序
思路，生产者和消费者共同处理一堆资源
生产者和消费者由多个线程处理
*/
class Res
{
private String name;
private boolean kai=false;
private int count=1;
public synchronized void setName(String name)
{
while (kai)//判断生产者里有没有内容，就是有没有生产商品，有生产的话就是true，true的话就要将线程冻结。所以wait，wait也要告诉是哪一个锁wait，同步函数的锁是this。
try{this.wait();}catch(Exception e){}
//当kai是false的时候，就代表里面没有值，就是没有商品，这时需要进行生产，所以执行以下语句
this.name = name+count++;//先进行初始化，把商品的名字和编号进行初始化
System.out.println(Thread.currentThread().getName()+"-----商品已经生产------"+this.name);//为了直观，把初始化的结果打印到控制台
kai = true;//生产完之后吧开关kai变为true，告诉别人，我有值啦，有值啦，所以就不能生产啦，下一步就是要wait，所以就要在冻结前把别人唤醒，因为有可能只唤醒本方，所以要把所有线程唤醒，notifyAll
this.notifyAll();
}
public synchronized void out()
{
while(!kai)//判断开关kai是否有值，假如是false的话就要冻结啦，因为我已经消费过啦，没有商品啦，额，对了，因为wait是有异常的，但是Runnable中没有，所以就要进行try处理
try{this.wait();}catch(Exception e){}
//kai是ture的话就是说我还有值，我还没有被销售，我要被销售，就进行下面的操作
System.out.println(Thread.currentThread().getName()+"----商品已售出---"+this.name);//把销售的结果打印出控制台
kai = false;//告诉别人我别销售完毕啦，把kai置为false，下一步就是要冻结啦，就要把所有线程唤醒，
this.notifyAll();
}
}
class Producer implements Runnable
{
private Res r;
Producer(Res r)//将资源传递给生产者，并进行赋值打印处理
{
this.r = r;
}
public void run()
{
while (true)//因为要打印多次，并且不知道打印次数，所以用while
{
r.setName("商品");
}
}
}
class Consumer implements Runnable
{
private Res r;
Consumer(Res r)//把资源传递给消费者，并进行输出处理
{
this.r = r;
}
public void run()
{
while (true)
{
r.out();
}
}
}
class h
{
public static void main(String[] args)
{
Res r = new Res();
Producer pro = new Producer(r);
Consumer con = new Consumer(r);
Thread t1 = new Thread(pro);
Thread t2 = new Thread(pro);
Thread t3 = new Thread(con);
Thread t4 = new Thread(con);
t1.start();
t2.start();
t3.start();
t4.start();
}
}

复制代码