瞌睡中的葡萄虎

博客园 首页 新随笔 联系 订阅 管理

请编写一个多线程程序,实现两个线程,其中一个线程完成对某个对象int成员变量的增加操作,即每次加1,另一个线程完成对该对象成员变量的减操作,即每次减1,同时要保证该变量的值不会小于0,不会大于1,该变量的初始值为0。

class Sample {

    private int number;

    public synchronized void increase() {
        while (0 != number) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        number++;
        System.out.println(number);
        this.notifyAll();
    }

    public synchronized void decrease() {
        while (0 == number) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        number--;
        System.out.println(number);
        this.notifyAll();

    }
}

class IncreaseThread implements Runnable {

    private Sample sample;

    public IncreaseThread(Sample sample) {
        this.sample = sample;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep((long)(Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            sample.increase();
        }
    }
}

class DecreaseThread implements Runnable {

    private Sample sample;

    public DecreaseThread(Sample sample) {
        this.sample = sample;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep((long)(Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            sample.decrease();
        }
    }
}

public class MainTest {
    public static void main(String[] args) {
        Sample sample = new Sample();
        Runnable runnable1 = new IncreaseThread(sample);
        Runnable runnable2 = new DecreaseThread(sample);

        Thread thread1 = new Thread(runnable1);
        Thread thread2 = new Thread(runnable2);

        thread1.start();
        thread2.start();
    }
} 

 

关于wait(),notify(),notifyAll()以及sleep()方法的关系

1)如果一个线程调用了某个对象的wait方法,那么该线程首先必须要拥有对象的锁(synchronized),换句话说,该wait方法必须出现在synchronized中;

2)如果一个线程调用了某个对象的wait方法,那么该线程就会释放该对象的锁;

3)在java对象中,有两种池(锁池和等待池);

4)如果一个线程调用了某个对象的wait方法,那么线程进入该对象的等待池(释放锁),如果未来某一时刻另一个线程调用了相同对象的notify/notifyAll方法,那么在该等待池中等待的线程就会起来进入该对象的锁池中,去等待获得该对象的锁,如果获得锁成功后,那么该线程将继续沿着wait方法之后的路径去执行;

5)Thread.sleep(long),如果一个线程调用了sleep方法睡眠,那么在睡眠的同时,不会丢失对象的锁的所有权;

6)wait、notify、notifyAll方法都是定义在Object类中的,而且是final的,因此会被所有的Java类所继承并且无法重写。这两个方法要求在调用时线程应该已经获得了对象的锁。这三个方法必须由同步监视对象/锁来调用,锁可以是任意的对象,任意的对象调用的方式一定定义在Object中;

7)notify方法是去等待池中随机的唤醒一个正在等待的线程,而notifyAll方法是唤醒所有等待池中的线程;

8)wait有个重载的方法public final void wait(long timeout),表示在指定的时候过了以后,线程自动进入等待池等待被调用;当指定的时间没有到的时候可以通过notify/notifyAll的方法唤醒;

9)wait():让当前线程放弃监视器进入等待,直到其他线程调用同一个监视器并调用notify()或notifyAll()为止;
notify():唤醒在同一对象监听器中调用wait方法的第一个线程;
notifyAll():唤醒在同一对象监听器中调用wait方法的所有线程。

10) wait可以指定时间也可以不指定时间;sleep必须指定时间;在同步中时,对CPU的执行权和锁的处理不同:wait释放执行权,释放锁;sleep释放执行权,不释放锁;

11) synchronized修饰的方法,因为该类的默认实例(this)是同步监视器,所有可以在同步方法中直接调用这三个方法;synchronized修饰的同步代码块,同步监视器是括号里的对象,所以必须使用该对象调用这三个方法;

12) 使用Lock对象来保证同步时,系统中不存在隐式的同步监视对象,那么就不能使用这三个方法了,那该怎么办呢?此时,Lock代替了同步方法/同步代码块,将同步的隐式锁变成显示锁操作,可以为一个锁加上多组监视器。Condition代替了同步监视器的功能。Condition对象通过Lock对象的newCondition()方法创建;
里面方法包括: await(): 等价于同步监听器的wait()方法;signal(): 等价于同步监听器的notify()方法; signalAll(): 等价于同步监听器的notifyAll()方法;
以前一个锁上只能有一组监视器方法。现在,一个Lock锁上可以多组监视器方法对象。可以实现一组负责生产者,一组负责消费者。

 

synchronized关键字的作用
1)在某个对象的所有synchronized方法中,在某一个时刻,只能有唯一的一个线程去访问这些synchronized方法;

2)如果一个方法是synchronized方法,那么该synchronized关键字给当前对象上锁(即this);

3)如果一个synchronized方法是static的,那么该synchronized关键字表示的是给当前对象所对应的Class对象上锁(每个类,不管生成多少对象,其对应的Class只有一个)。

 

posted on 2014-09-25 14:22  瞌睡中的葡萄虎  阅读(306)  评论(0编辑  收藏  举报