当前位置:首页 > 开发 > 编程语言 > 多线程 > 正文

java 多线程 wait nofity notifyAll 线程唤醒之后的执行

发表于: 2014-10-28   作者:abc08010051   来源:转载   浏览:
摘要: 下面是我自己写的一个生产者消费者程序   /** * 馒头 */ class Mantou { } /** * 仓库,用来存放馒头 */ class GodOwn { private List<Mantou> mantouList; int max = 10; GodOwn () {

下面是我自己写的一个生产者消费者程序

 

/**
 * 馒头
 */
class Mantou {

}

/**
 * 仓库,用来存放馒头
 */
class GodOwn {
    private List<Mantou> mantouList;

    int max = 10;

    GodOwn () {
        this.mantouList = Lists.newArrayList();
    }

    /**
     * 生产
     */
    public synchronized void produce () {
        System.out.println("进入生产线程..." + Thread.currentThread().getName());
        if (this.mantouList.size() > 0 || this.mantouList.size() >= max - 3) {
            try {
                System.out.println("生产线程被阻塞,线程名称为:之前:" + Thread.currentThread().getName());
                this.wait();
                System.out.println("生产线程被阻塞,线程名称为:之后:" + Thread.currentThread().getName());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        System.out.println("生产线程在执行,线程名称为:" + Thread.currentThread().getName());
        this.mantouList.add(new Mantou());
        this.mantouList.add(new Mantou());
        this.mantouList.add(new Mantou());
        System.out.println("生产了3个馒头,现在的馒头数是:" + this.mantouList.size());
        notifyAll();
    }

    /**
     * 消费
     */
    public synchronized void reduce () {
        System.out.println("进入消费线程..." + Thread.currentThread().getName());
        if (this.mantouList.size() <= 0) {
            try {
                System.out.println("消费线程被阻塞,线程名称为:之前:" + Thread.currentThread().getName());
                this.wait();
                System.out.println("消费线程被阻塞,线程名称为:之后:" + Thread.currentThread().getName());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        System.out.println("消费线程在执行,线程名称为:" + Thread.currentThread().getName());
        this.mantouList.remove(0);
        System.out.println("消费了1个馒头,现在的馒头数是:" + this.mantouList.size());
        notifyAll();
    }

}

/**
 * 消费者
 */
class Customer extends Thread  {

    private GodOwn godOwn;

    public Customer (GodOwn godOwn) {
        this.godOwn = godOwn;
    }

    public void run () {
        godOwn.reduce();
    }

}

/**
 * 生产者
 */
class Producer extends Thread  {

    private GodOwn godOwn;

    public Producer (GodOwn godOwn) {
        this.godOwn = godOwn;
    }

    public void run () {
        godOwn.produce();
    }

}

 

执行结果为:

    

进入生产线程...Thread-0
生产线程在执行,线程名称为:Thread-0
生产了3个馒头,现在的馒头数是:3
进入生产线程...Thread-4
生产线程被阻塞,线程名称为:之前:Thread-4
进入生产线程...Thread-2
生产线程被阻塞,线程名称为:之前:Thread-2
进入生产线程...Thread-6
生产线程被阻塞,线程名称为:之前:Thread-6
进入生产线程...Thread-8
生产线程被阻塞,线程名称为:之前:Thread-8
进入生产线程...Thread-1
生产线程被阻塞,线程名称为:之前:Thread-1
进入生产线程...Thread-3
生产线程被阻塞,线程名称为:之前:Thread-3
进入生产线程...Thread-5
生产线程被阻塞,线程名称为:之前:Thread-5
进入生产线程...Thread-7
生产线程被阻塞,线程名称为:之前:Thread-7
进入生产线程...Thread-9
生产线程被阻塞,线程名称为:之前:Thread-9
进入消费线程...Thread-10
消费线程在执行,线程名称为:Thread-10
消费了1个馒头,现在的馒头数是:2
生产线程被阻塞,线程名称为:之后:Thread-9
生产线程在执行,线程名称为:Thread-9
生产了3个馒头,现在的馒头数是:5
生产线程被阻塞,线程名称为:之后:Thread-7
生产线程在执行,线程名称为:Thread-7
生产了3个馒头,现在的馒头数是:8
进入消费线程...Thread-12
消费线程在执行,线程名称为:Thread-12
消费了1个馒头,现在的馒头数是:7
生产线程被阻塞,线程名称为:之后:Thread-5
生产线程在执行,线程名称为:Thread-5
生产了3个馒头,现在的馒头数是:10
生产线程被阻塞,线程名称为:之后:Thread-3
生产线程在执行,线程名称为:Thread-3
生产了3个馒头,现在的馒头数是:13
进入消费线程...Thread-14
消费线程在执行,线程名称为:Thread-14
消费了1个馒头,现在的馒头数是:12
生产线程被阻塞,线程名称为:之后:Thread-1
生产线程在执行,线程名称为:Thread-1
生产了3个馒头,现在的馒头数是:15
生产线程被阻塞,线程名称为:之后:Thread-8
生产线程在执行,线程名称为:Thread-8
生产了3个馒头,现在的馒头数是:18
生产线程被阻塞,线程名称为:之后:Thread-6
生产线程在执行,线程名称为:Thread-6
生产了3个馒头,现在的馒头数是:21
生产线程被阻塞,线程名称为:之后:Thread-2
生产线程在执行,线程名称为:Thread-2
生产了3个馒头,现在的馒头数是:24
生产线程被阻塞,线程名称为:之后:Thread-4
生产线程在执行,线程名称为:Thread-4
生产了3个馒头,现在的馒头数是:27
进入消费线程...Thread-13
消费线程在执行,线程名称为:Thread-13
消费了1个馒头,现在的馒头数是:26
进入消费线程...Thread-15
消费线程在执行,线程名称为:Thread-15
消费了1个馒头,现在的馒头数是:25
进入消费线程...Thread-11
消费线程在执行,线程名称为:Thread-11
消费了1个馒头,现在的馒头数是:24
进入消费线程...Thread-17
消费线程在执行,线程名称为:Thread-17
消费了1个馒头,现在的馒头数是:23
进入消费线程...Thread-16
消费线程在执行,线程名称为:Thread-16
消费了1个馒头,现在的馒头数是:22
进入消费线程...Thread-19
消费线程在执行,线程名称为:Thread-19
消费了1个馒头,现在的馒头数是:21
进入消费线程...Thread-18
消费线程在执行,线程名称为:Thread-18
消费了1个馒头,现在的馒头数是:20
进入消费线程...Thread-20
消费线程在执行,线程名称为:Thread-20
消费了1个馒头,现在的馒头数是:19
进入消费线程...Thread-21
消费线程在执行,线程名称为:Thread-21
消费了1个馒头,现在的馒头数是:18
进入消费线程...Thread-22
消费线程在执行,线程名称为:Thread-22
消费了1个馒头,现在的馒头数是:17
进入消费线程...Thread-23
消费线程在执行,线程名称为:Thread-23
消费了1个馒头,现在的馒头数是:16
进入消费线程...Thread-24
消费线程在执行,线程名称为:Thread-24
消费了1个馒头,现在的馒头数是:15
进入消费线程...Thread-25
消费线程在执行,线程名称为:Thread-25
消费了1个馒头,现在的馒头数是:14
进入消费线程...Thread-26
消费线程在执行,线程名称为:Thread-26
消费了1个馒头,现在的馒头数是:13
进入消费线程...Thread-27
消费线程在执行,线程名称为:Thread-27
消费了1个馒头,现在的馒头数是:12
进入消费线程...Thread-28
消费线程在执行,线程名称为:Thread-28
消费了1个馒头,现在的馒头数是:11
进入消费线程...Thread-29
消费线程在执行,线程名称为:Thread-29
消费了1个馒头,现在的馒头数是:10
进入消费线程...Thread-30
消费线程在执行,线程名称为:Thread-30
消费了1个馒头,现在的馒头数是:9
进入消费线程...Thread-31
消费线程在执行,线程名称为:Thread-31
消费了1个馒头,现在的馒头数是:8
进入消费线程...Thread-32
消费线程在执行,线程名称为:Thread-32
消费了1个馒头,现在的馒头数是:7
进入消费线程...Thread-33
消费线程在执行,线程名称为:Thread-33
消费了1个馒头,现在的馒头数是:6
进入消费线程...Thread-34
消费线程在执行,线程名称为:Thread-34
消费了1个馒头,现在的馒头数是:5
进入消费线程...Thread-35
消费线程在执行,线程名称为:Thread-35
消费了1个馒头,现在的馒头数是:4
进入消费线程...Thread-37
消费线程在执行,线程名称为:Thread-37
消费了1个馒头,现在的馒头数是:3
进入消费线程...Thread-36
消费线程在执行,线程名称为:Thread-36
消费了1个馒头,现在的馒头数是:2
进入消费线程...Thread-38
消费线程在执行,线程名称为:Thread-38
消费了1个馒头,现在的馒头数是:1
进入消费线程...Thread-39
消费线程在执行,线程名称为:Thread-39
消费了1个馒头,现在的馒头数是:0

 对于线程被notifyAll()以后,线程会进入等待cpu分配时间片,分配到后执行,那么被吵醒的线程从哪里执行代码呢?

 

      有两种假设:

      1 从同步代码块开始执行

      2 从wait()方法后开始执行

 根据执行结果我们可以判断,被吵醒的线程是从wait()方法后开始执行的,因为从打印结果我们可以排除第一种假设,因为每次进入方法的时候都会打印“进入生产线程...” + 线程名称,这一段,这一段在打印结果中是唯一的;

 根据上面的打印结果看以看到, 打印信息“生产线程被阻塞,线程名称为:之后:” + 线程名称,和打印信息:“生产线程在执行,线程名称为:” + 线程名称都是紧挨着的,这说明当线程被吵醒之后是从wait()方法后开始执行的;

 

     从上面的代码可以看到,在生产馒头的时候,是做最大数限制的,可是从打印结果可以看到,馒头数最多的时候有27个,也就是说我们的限制没起作用,根本原因是因为等待的线程被吵醒之后并没有重新执行同步代码块,

而是从wait()方法后的代码执行的

   

    现在可以这么来控制代码来做最大限制控制:

    /**
     * 生产
     */
    public synchronized void produce () {
        System.out.println("进入生产线程..." + Thread.currentThread().getName());
        while (this.mantouList.size() > 0 || this.mantouList.size() >= max - 3) {
            try {
                System.out.println("生产线程被阻塞,线程名称为:之前:" + Thread.currentThread().getName());
                this.wait();
                System.out.println("生产线程被阻塞,线程名称为:之后:" + Thread.currentThread().getName());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        System.out.println("生产线程在执行,线程名称为:" + Thread.currentThread().getName());
        this.mantouList.add(new Mantou());
        this.mantouList.add(new Mantou());
        this.mantouList.add(new Mantou());
        System.out.println("生产了3个馒头,现在的馒头数是:" + this.mantouList.size());
        notifyAll();
    }


    /**
     * 消费
     */
    public synchronized void reduce () {
        System.out.println("进入消费线程..." + Thread.currentThread().getName());
        while (this.mantouList.size() <= 0) {
            try {
                System.out.println("消费线程被阻塞,线程名称为:之前:" + Thread.currentThread().getName());
                this.wait();
                System.out.println("消费线程被阻塞,线程名称为:之后:" + Thread.currentThread().getName());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        System.out.println("消费线程在执行,线程名称为:" + Thread.currentThread().getName());
        this.mantouList.remove(0);
        System.out.println("消费了1个馒头,现在的馒头数是:" + this.mantouList.size());
        notifyAll();
    }

   生产和消费方法和原来的区别就是判断线程阻塞的代码块由if改成while,执行结果如下:

进入生产线程...Thread-0
生产线程在执行,线程名称为:Thread-0
生产了3个馒头,现在的馒头数是:3
进入生产线程...Thread-8
生产线程被阻塞,线程名称为:之前:Thread-8
进入生产线程...Thread-9
生产线程被阻塞,线程名称为:之前:Thread-9
进入生产线程...Thread-6
生产线程被阻塞,线程名称为:之前:Thread-6
进入生产线程...Thread-7
生产线程被阻塞,线程名称为:之前:Thread-7
进入生产线程...Thread-5
生产线程被阻塞,线程名称为:之前:Thread-5
进入生产线程...Thread-4
生产线程被阻塞,线程名称为:之前:Thread-4
进入生产线程...Thread-3
生产线程被阻塞,线程名称为:之前:Thread-3
进入生产线程...Thread-1
生产线程被阻塞,线程名称为:之前:Thread-1
进入生产线程...Thread-2
生产线程被阻塞,线程名称为:之前:Thread-2
进入消费线程...Thread-10
消费线程在执行,线程名称为:Thread-10
消费了1个馒头,现在的馒头数是:2
生产线程被阻塞,线程名称为:之后:Thread-2
生产线程被阻塞,线程名称为:之前:Thread-2
生产线程被阻塞,线程名称为:之后:Thread-1
生产线程被阻塞,线程名称为:之前:Thread-1
进入消费线程...Thread-11
消费线程在执行,线程名称为:Thread-11
消费了1个馒头,现在的馒头数是:1
生产线程被阻塞,线程名称为:之后:Thread-3
生产线程被阻塞,线程名称为:之前:Thread-3
进入消费线程...Thread-12
消费线程在执行,线程名称为:Thread-12
消费了1个馒头,现在的馒头数是:0
生产线程被阻塞,线程名称为:之后:Thread-4
生产线程在执行,线程名称为:Thread-4
生产了3个馒头,现在的馒头数是:3
生产线程被阻塞,线程名称为:之后:Thread-5
生产线程被阻塞,线程名称为:之前:Thread-5
进入消费线程...Thread-13
消费线程在执行,线程名称为:Thread-13
消费了1个馒头,现在的馒头数是:2
进入消费线程...Thread-14
消费线程在执行,线程名称为:Thread-14
消费了1个馒头,现在的馒头数是:1
生产线程被阻塞,线程名称为:之后:Thread-7
生产线程被阻塞,线程名称为:之前:Thread-7
生产线程被阻塞,线程名称为:之后:Thread-6
生产线程被阻塞,线程名称为:之前:Thread-6
生产线程被阻塞,线程名称为:之后:Thread-9
生产线程被阻塞,线程名称为:之前:Thread-9
生产线程被阻塞,线程名称为:之后:Thread-8
生产线程被阻塞,线程名称为:之前:Thread-8
进入消费线程...Thread-16
消费线程在执行,线程名称为:Thread-16
消费了1个馒头,现在的馒头数是:0
进入消费线程...Thread-17
消费线程被阻塞,线程名称为:之前:Thread-17
进入消费线程...Thread-15
消费线程被阻塞,线程名称为:之前:Thread-15
生产线程被阻塞,线程名称为:之后:Thread-5
生产线程在执行,线程名称为:Thread-5
生产了3个馒头,现在的馒头数是:3
生产线程被阻塞,线程名称为:之后:Thread-3
生产线程被阻塞,线程名称为:之前:Thread-3
生产线程被阻塞,线程名称为:之后:Thread-1
生产线程被阻塞,线程名称为:之前:Thread-1
进入消费线程...Thread-19
消费线程在执行,线程名称为:Thread-19
消费了1个馒头,现在的馒头数是:2
生产线程被阻塞,线程名称为:之后:Thread-2
生产线程被阻塞,线程名称为:之前:Thread-2
生产线程被阻塞,线程名称为:之后:Thread-1
生产线程被阻塞,线程名称为:之前:Thread-1
生产线程被阻塞,线程名称为:之后:Thread-3
生产线程被阻塞,线程名称为:之前:Thread-3
消费线程被阻塞,线程名称为:之后:Thread-15
消费线程在执行,线程名称为:Thread-15
消费了1个馒头,现在的馒头数是:1
消费线程被阻塞,线程名称为:之后:Thread-17
消费线程在执行,线程名称为:Thread-17
消费了1个馒头,现在的馒头数是:0
生产线程被阻塞,线程名称为:之后:Thread-8
生产线程在执行,线程名称为:Thread-8
生产了3个馒头,现在的馒头数是:3
进入消费线程...Thread-20
消费线程在执行,线程名称为:Thread-20
消费了1个馒头,现在的馒头数是:2
进入消费线程...Thread-22
消费线程在执行,线程名称为:Thread-22
消费了1个馒头,现在的馒头数是:1
生产线程被阻塞,线程名称为:之后:Thread-9
生产线程被阻塞,线程名称为:之前:Thread-9
进入消费线程...Thread-26
消费线程在执行,线程名称为:Thread-26
消费了1个馒头,现在的馒头数是:0
生产线程被阻塞,线程名称为:之后:Thread-6
生产线程在执行,线程名称为:Thread-6
生产了3个馒头,现在的馒头数是:3
生产线程被阻塞,线程名称为:之后:Thread-7
生产线程被阻塞,线程名称为:之前:Thread-7
进入消费线程...Thread-27
消费线程在执行,线程名称为:Thread-27
消费了1个馒头,现在的馒头数是:2
进入消费线程...Thread-18
消费线程在执行,线程名称为:Thread-18
消费了1个馒头,现在的馒头数是:1
进入消费线程...Thread-28
消费线程在执行,线程名称为:Thread-28
消费了1个馒头,现在的馒头数是:0
进入消费线程...Thread-30
消费线程被阻塞,线程名称为:之前:Thread-30
生产线程被阻塞,线程名称为:之后:Thread-7
生产线程在执行,线程名称为:Thread-7
生产了3个馒头,现在的馒头数是:3
生产线程被阻塞,线程名称为:之后:Thread-9
生产线程被阻塞,线程名称为:之前:Thread-9
进入消费线程...Thread-29
消费线程在执行,线程名称为:Thread-29
消费了1个馒头,现在的馒头数是:2
进入消费线程...Thread-24
消费线程在执行,线程名称为:Thread-24
消费了1个馒头,现在的馒头数是:1
进入消费线程...Thread-25
消费线程在执行,线程名称为:Thread-25
消费了1个馒头,现在的馒头数是:0
生产线程被阻塞,线程名称为:之后:Thread-3
生产线程在执行,线程名称为:Thread-3
生产了3个馒头,现在的馒头数是:3
生产线程被阻塞,线程名称为:之后:Thread-1
生产线程被阻塞,线程名称为:之前:Thread-1
生产线程被阻塞,线程名称为:之后:Thread-2
生产线程被阻塞,线程名称为:之前:Thread-2
进入消费线程...Thread-23
消费线程在执行,线程名称为:Thread-23
消费了1个馒头,现在的馒头数是:2
进入消费线程...Thread-21
消费线程在执行,线程名称为:Thread-21
消费了1个馒头,现在的馒头数是:1
生产线程被阻塞,线程名称为:之后:Thread-2
生产线程被阻塞,线程名称为:之前:Thread-2
生产线程被阻塞,线程名称为:之后:Thread-1
生产线程被阻塞,线程名称为:之前:Thread-1
进入消费线程...Thread-34
消费线程在执行,线程名称为:Thread-34
消费了1个馒头,现在的馒头数是:0
进入消费线程...Thread-32
消费线程被阻塞,线程名称为:之前:Thread-32
进入消费线程...Thread-31
消费线程被阻塞,线程名称为:之前:Thread-31
进入消费线程...Thread-36
消费线程被阻塞,线程名称为:之前:Thread-36
生产线程被阻塞,线程名称为:之后:Thread-9
生产线程在执行,线程名称为:Thread-9
生产了3个馒头,现在的馒头数是:3
进入消费线程...Thread-35
消费线程在执行,线程名称为:Thread-35
消费了1个馒头,现在的馒头数是:2
消费线程被阻塞,线程名称为:之后:Thread-30
消费线程在执行,线程名称为:Thread-30
消费了1个馒头,现在的馒头数是:1
消费线程被阻塞,线程名称为:之后:Thread-36
消费线程在执行,线程名称为:Thread-36
消费了1个馒头,现在的馒头数是:0
消费线程被阻塞,线程名称为:之后:Thread-31
消费线程被阻塞,线程名称为:之前:Thread-31
消费线程被阻塞,线程名称为:之后:Thread-32
消费线程被阻塞,线程名称为:之前:Thread-32
进入消费线程...Thread-39
消费线程被阻塞,线程名称为:之前:Thread-39
进入消费线程...Thread-37
消费线程被阻塞,线程名称为:之前:Thread-37
进入消费线程...Thread-38
消费线程被阻塞,线程名称为:之前:Thread-38
生产线程被阻塞,线程名称为:之后:Thread-1
生产线程在执行,线程名称为:Thread-1
生产了3个馒头,现在的馒头数是:3
生产线程被阻塞,线程名称为:之后:Thread-2
生产线程被阻塞,线程名称为:之前:Thread-2
进入消费线程...Thread-33
消费线程在执行,线程名称为:Thread-33
消费了1个馒头,现在的馒头数是:2
生产线程被阻塞,线程名称为:之后:Thread-2
生产线程被阻塞,线程名称为:之前:Thread-2
消费线程被阻塞,线程名称为:之后:Thread-38
消费线程在执行,线程名称为:Thread-38
消费了1个馒头,现在的馒头数是:1
消费线程被阻塞,线程名称为:之后:Thread-37
消费线程在执行,线程名称为:Thread-37
消费了1个馒头,现在的馒头数是:0
消费线程被阻塞,线程名称为:之后:Thread-39
消费线程被阻塞,线程名称为:之前:Thread-39
消费线程被阻塞,线程名称为:之后:Thread-32
消费线程被阻塞,线程名称为:之前:Thread-32
消费线程被阻塞,线程名称为:之后:Thread-31
消费线程被阻塞,线程名称为:之前:Thread-31
生产线程被阻塞,线程名称为:之后:Thread-2
生产线程在执行,线程名称为:Thread-2
生产了3个馒头,现在的馒头数是:3
消费线程被阻塞,线程名称为:之后:Thread-31
消费线程在执行,线程名称为:Thread-31
消费了1个馒头,现在的馒头数是:2
消费线程被阻塞,线程名称为:之后:Thread-32
消费线程在执行,线程名称为:Thread-32
消费了1个馒头,现在的馒头数是:1
消费线程被阻塞,线程名称为:之后:Thread-39
消费线程在执行,线程名称为:Thread-39
消费了1个馒头,现在的馒头数是:0

 

   改成while之后,线程被吵醒之后从wait()之后执行,然后检查while循环体的条件,如果超过最大个数限制,则继续阻塞

 

 

二: 锁的重入性

        在java内部,同一线程在调用自己类中其他synchronized方法/块或调用父类的synchronized方法/块都不会阻碍该线程的执行,就是说同一线程对同一个对象锁是可重入的,而且同一个线程可以获取同一把锁多次,也就是可以多次重入。

       锁重入后的退出:

       我们再来看看重入锁是怎么实现可重入性的,其实现方法是为每个锁关联一个线程持有者和计数器,当计数器为0时表示该锁没有被任何线程持有,那么任何线程都可能获得该锁而调用相应的方法;当某一线程请求成功后,JVM会记下锁的持有线程,并且将计数器置为1;此时其它线程请求该锁,则必须等待;而该持有锁的线程如果再次请求这个锁,就可以再次拿到这个锁,同时计数器会递增;当线程退出同步代码块时,计数器会递减,如果计数器为0,则释放该锁。

        链接:http://www.tuicool.com/articles/Fr6FBnY

 

三 中断锁

     Synchronized无法响应线程中断,ReentrantLock可以响应线程中断

 

java 多线程 wait nofity notifyAll 线程唤醒之后的执行

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

编辑推荐
1、问题的引出 class MyThread implements Runnable{ private int ticket = 5 ; // 假设一共有5张票
1、问题的引出 class MyThread implements Runnable{ private int ticket = 5 ; // 假设一共有5张票
线程的阻塞和唤醒在多线程并发过程中是一个关键点,当线程数量达到很大的数量级时,并发可能带来很
发一下牢骚和主题无关: 总结一下多线程中之重要点——等待唤醒制机 先用一个艰深的例子来明说等待
概要 本章,会对线程等待/唤醒方法进行介绍。涉及到的内容包括: 1. wait(), notify(), notifyAll()
Java 中除了关键字 synchronized 能够实现线程同步外,还可以使用 wait 和 notify/notify 实现同步
wait(),notify(),notifyAll()三个方法不是Thread的方法,而是Object的方法。意味着所有对象都有这三
Java 中除了关键字 synchronized 能够实现线程同步外,还可以使用 wait 和 notify/notify 实现同步
(转载请注明出处:http://blog.csdn.net/buptgshengod) 1.背景 Java多线程操作运用很广,特别是在
注意:这些方法属于Object,而不属于Thread。 每一个对象除了有一个锁之外,还有一个等待队列(wait
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号