多线程问题

本帖最后由 NewDemo 于 2014-5-5 21:52 编辑

public class ThreadTest2 {
/**
* @param args
* 生产者消费例子实现
* 思路：1.创建一个商品资源的类，并在其中定义两个加锁的方法用于模拟生产和消费的行为 2.定义生产者和消费者的类并实现Runnable接口
* 3.主函数中创建线程并关联资源。
*/
public static void main(String[] args) {
//创建线程并关联资源
Resource r = new Resource();
new Thread(new Producer(r)).start();
new Thread(new Producer(r)).start();
new Thread(new Producer(r)).start();
new Thread(new Producer(r)).start();
new Thread(new Consumer(r)).start();
new Thread(new Consumer(r)).start();
// new Thread(new Consumer(r)).start();
// new Thread(new Consumer(r)).start();
}
}
//创建商品的类，公共资源
class Resource{
private int count = 0;//用于记录商品的编号
private boolean flag = false;//定义标记用来控制线程的运行交替
//模拟生产行为
public synchronized void set(){
while(flag)
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
count++;
flag = true;
System.out.println(Thread.currentThread().getName()+"生产。。"+count);
this.notifyAll();
}
//模拟消费行为
public synchronized void out(){
while(!flag)
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
flag = false;
System.out.println(Thread.currentThread().getName()+"消费。。。。。"+count);
this.notifyAll();
}
}
//生产者的类，实现接口，复写run方法
class Producer implements Runnable{
private Resource r;
Producer(Resource r){
this.r=r;
}
@Override
public void run() {
while(true){
r.set();
}
}
}
//消费者的类，实现接口，复写run方法
class Consumer implements Runnable{
private Resource r;
Consumer(Resource r){
this.r=r;
}
@Override
public void run() {
while(true){
r.out();
}
}
}

复制代码

毕老师在讲课时用生产者t1，t2，消费者t3，t4解释了判断标记的时候为什么不能用if，但是我想问的是t1等待的时候不是还没有释放锁吗，那t2是如何拿到锁并也等待了呢？
看下wait方法的注释，当调用wait方法时就会释放锁，并且这个方法应该一直在循环中使用。

随风而去 · 随风而去

这个是我写的一个生产消费者示例你可以研究下

package test2;
import java.util.ArrayList;
import java.util.List;
/**
* 生成消费者模式
* @author 李昂志
*
*/
public class ThreadRun {
public static void main(String[] args) {
new Thread(new Factory("福特")).start(); //两家汽车店
new Thread(new Factory("宝马")).start();
new Thread(new Customer("马晓")).start(); //5个客户
new Thread(new Customer("大米")).start();
new Thread(new Customer("小跳")).start();
new Thread(new Customer("Marry")).start();
new Thread(new Customer("Jack")).start();
}
}
/**
*生成者
*生成汽车
*/
class Factory implements Runnable{
String name ;
public Factory(String name){
this.name = name;
}
@Override
public void run() {
// TODO Auto-generated method stub
int i = 0 ;
while(true){
i++;
try {
Thread.sleep(800); //每生产一辆汽车休息0.8s
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//生产汽车
Stores4S.getInstance().protect(name,i);
}
}
}
/**
* 汽车
* @author 李昂志
*/
class Car{
String name;
public Car(String name){
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Car() {
}
}
/**
* 消费者
* 消费汽车
*/
class Customer implements Runnable{
String name ; //消费者的名字
private Car c ;
public Customer(String name){
this.name = name;
}
@Override
public void run() {
while(true){
if(c != null ) break; //如果消费者已经买到车则退出买车的方法
try {
Thread.sleep(1000); //消费者每买辆车休息1s
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
c = Stores4S.getInstance().custom(name); //消费者买车
}
}
}
/**
* 生产者用来卖东西
* 消费这买东西的地方先叫做门店吧
* 一家4s汽车店汽车店是唯一的
* @author 李昂志
*/
class Stores4S {
private static Stores4S s = new Stores4S();
private static final int MAX = 5;
private List<Car> ls = new ArrayList<Car>(); //汽车店的容量
private Stores4S(){};
/**
* 饿汉单利模式唯一且线程安全
*/
public static Stores4S getInstance(){
return s ;
}
/**
* 卖汽车
*/
public synchronized Car custom(String name){
while(ls.isEmpty()){
try {
System.out.println("店里的汽车已销售完毕请生产了再买！");
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
Car c = ls.get(ls.size()-1);System.out.println(name +" 买了一辆型号为:"+c.getName()+" 的汽车");
ls.remove(c);
notifyAll();
return c;
}
/**
* 4s店去汽车商拿货
* @param name
* @param i
*/
public synchronized void protect(String name, int i){
while(ls.size()>MAX){
try {
System.out.println("店里的汽车已满请消费了再生产！");
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
ls.add(new Car(name+"_"+i));
System.out.println(name +"汽车商生产了一辆型号为: "+ls.get(ls.size()-1).getName()+" 的汽车");
notifyAll();
}
}

复制代码

heima_xyu · heima_xyu

class Resource{
      private int count = 0;//用于记录商品的编号
      private boolean flag = false;//定义标记用来控制线程的运行交替
      //模拟生产行为
      public synchronized void set(){
if(flag)                                       //假设换成if，假设    1.进入线程t1，因为flag为false
try {                                              //5.这时t2进来，也等待，然后执行消费行为的t3,t4
                              this.wait();          //4.因为flag为true,t1等待
                     } catch (InterruptedException e) {
                              e.printStackTrace();            //8.t1醒来，执行以下代码，在打印语句后，t2取得执行权，也打印了一次。
                     }                                                    //2.t1没有执行这段代码
            count++;
            flag = true;
            System.out.println(Thread.currentThread().getName()+"生产。。"+count);
            this.notifyAll();                                                 //3.flag变更为true，t1唤醒其他线程，但也可能继续循环，假设继续循环
      }

      //模拟消费行为
      public synchronized void out(){
if(!flag)                                  //6.t3进来，flag为！true,跳过try｛｝catch{}代码
                     try {
                              this.wait();
                     } catch (InterruptedException e) {
                              e.printStackTrace();
                     }
            flag = false;
            System.out.println(Thread.currentThread().getName()+"消费。。。。。"+count);
            this.notifyAll();                   //7.flag变更为false， t3唤醒其他线程，假设是t1和t2取得CPU使用权
      }
}

//1--8的步骤即线程不安全的原因所在，其实即使是while，该程序还是有微小的可能出错，notifyAll不如Lock系统的Condition的某个对象调用sig
nal()方法

NewDemo · NewDemo

heima_xyu 发表于 2014-5-5 17:56
class Resource{
private int count = 0;//用于记录商品的编号
private boolean flag = fa ...

你说的这个毕老师在视频里讲到了，我想问的是t1等待的时候不是还没有释放锁吗，那t2是如何拿到锁并也等待了呢？

heima_xyu · heima_xyu

NewDemo 发表于 2014-5-5 18:03
你说的这个毕老师在视频里讲到了，我想问的是t1等待的时候不是还没有释放锁吗，那t2是如何拿到锁并也等待 ...

java的wait吊起线程的时候会释放synchronized锁

NewDemo · NewDemo

heima_xyu 发表于 2014-5-5 19:22
java的wait吊起线程的时候会释放synchronized锁

{:2_31:}原来是这样，刚才看了下源码，里面竟然还专门给出了例子，这个wait方法要一直在循环中使用，终于解决了这个疑惑，活到老，学到老。。

wyqs92 · wyqs92

public class ThreadTest2 {
/**
* @param args
* 生产者消费例子实现
* 思路：1.创建一个商品资源的类，并在其中定义两个加锁的方法用于模拟生产和消费的行为 2.定义生产者和消费者的类并实现Runnable接口
* 3.主函数中创建线程并关联资源。
*/
public static void main(String[] args) {
//创建线程并关联资源
Resource r = new Resource();
new Thread(new Producer(r)).start();
new Thread(new Producer(r)).start();
new Thread(new Producer(r)).start();
new Thread(new Producer(r)).start();
new Thread(new Consumer(r)).start();
new Thread(new Consumer(r)).start();
// new Thread(new Consumer(r)).start();
// new Thread(new Consumer(r)).start();
}
}
//创建商品的类，公共资源
class Resource{
private int count = 0;//用于记录商品的编号
private boolean flag = false;//定义标记用来控制线程的运行交替
//模拟生产行为
public synchronized void set(){
while(flag)//此处如果是while，它是一个循环。如果不满足就不执行。当条件满足时，向下执行wait()，下一次被唤醒之后还需要继续判断while中的条件。但是如果改为if，它表示的是判断，如果为真向下执行，就执行了wait()，当被唤醒后，它就直接执行wait()以下的语句。
还有就是你要知道wait()表示等待，它要将正在执行的线程释放其执行资格和执行权，并存储到线程池中。
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
count++;
flag = true;
System.out.println(Thread.currentThread().getName()+"生产。。"+count);
this.notifyAll();
}
//模拟消费行为
public synchronized void out(){
while(!flag)
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
flag = false;
System.out.println(Thread.currentThread().getName()+"消费。。。。。"+count);
this.notifyAll();
}
}
//生产者的类，实现接口，复写run方法
class Producer implements Runnable{
private Resource r;
Producer(Resource r){
this.r=r;
}
@Override
public void run() {
while(true){
r.set();
}
}
}
//消费者的类，实现接口，复写run方法
class Consumer implements Runnable{
private Resource r;
Consumer(Resource r){
this.r=r;
}
@Override
public void run() {
while(true){
r.out();
}
}
}

复制代码

帐号		自动登录	找回密码
密码			加入黑马

多线程问题

7 个回复

点评

评分

黑马骑士勋章