浅谈Java中的线程通信和单例模式

线程通信和单例模式

1. 多线程

1.1 线程的生命周期

1.2 线程通信使用的方法介绍

以下方法都是Object类内方法:
1. wait()
	作用: 线程进入阻塞状态，并且【开启】锁对象
	调用当前方法所处的线程代码块对应的线程对象进入阻塞状态！！！
	
2. notify();	
	作用：唤醒线程池中一个【相关】使用wait方法进入阻塞状态的一个线程，并且【开启】锁对象

3. notifyAll();
	作用：唤醒线程池中所有【相关】使用wait方法进入阻塞状态的线程，并且【开启】锁对象

1.3 线程通信模版【生产者消费者模式图例】

生产者:
	一个负责商品生产
消费者:
	一个负责商品购买
商品是一个【共享资源】

1.4 生产者消费者共享资源问题解决

希望的效果是商品对象就一个，而通过生产者和消费者线程对象修改对应的商品状态。

成员变量：
	这里使用成员变量 Goods类型操作指定对应的Goods类对象！！！
局部变量：
	不合适！！！
静态成员变量：
	我们之前选择作为共享资源很常见的一种方式，这里如果在两个线程对象中使用静态成员变量Goods类型同时指向同一个Goods类对象，是可以实现共享资源，但是会导致资源浪费，并且没有任何的复用性！！！因为多消费者和多生产者情况下，数据无法满足多种情况！！！
	【不合适！！！】

1.5 线程通信代码实现和注意实现

class Goods {
    private String name;
    private float price;
    private boolean shouldProduct;

    public Goods() {
    }

    public Goods(String name, float price, boolean shouldProduct) {
        this.name = name;
        this.price = price;
        this.shouldProduct = shouldProduct;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
    }

    public boolean isShouldProduct() {
        return shouldProduct;
    }

    public void setShouldProduct(boolean shouldProduct) {
        this.shouldProduct = shouldProduct;
    }
}

class Customer implements Runnable {
    private Goods goods;

    public Customer() {
    }

    public Customer(Goods goods) {
        this.goods = goods;
    }

    public void setGoods(Goods goods) {
        this.goods = goods;
    }

    public Goods getGoods() {
        return goods;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (goods) {
                if (!goods.isShouldProduct()) {
                    // 消费过程
                    System.out.println("消费者购买了:" + goods.getName() + ":" + goods.getPrice());

                    // 修改标记
                    goods.setShouldProduct(true);

                    // 唤醒生产者
                    goods.notify();
                } else {
                    // 无法购买消费者休眠
                    System.out.println("消费者进入休眠状态");
                    try {
                        goods.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

class Producer implements Runnable {
    private Goods goods;

    public Producer() {
    }

    public Producer(Goods goods) {
        this.goods = goods;
    }

    public void setGoods(Goods goods) {
        this.goods = goods;
    }

    public Goods getGoods() {
        return goods;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (goods) {
                if (goods.isShouldProduct()) {
                    // 生产过程
                    if (Math.random() > 0.5) {
                        goods.setName("旺仔牛奶");
                        goods.setPrice(6.0F);
                    } else {
                        goods.setName("旺旺雪米饼");
                        goods.setPrice(2.5F);
                    }
                    System.out.println("生产者生产了 : " + goods.getName() + ":" + goods.getPrice());
                    // 生产完成修改标记
                    goods.setShouldProduct(false);

                    // 唤醒消费者过程
                    goods.notify();
                } else {
                    // 进入休眠状态
                    System.out.println("生产者进入休眠状态");
                    try {
                        goods.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

public class Demo1 {
    public static void main(String[] args) {
        Goods goods = new Goods("旺旺雪米饼", 2.5F, true);

        Producer producer = new Producer(goods);
        Customer customer = new Customer(goods);

        new Thread(producer).start();
        new Thread(customer).start();
    }
}

2. 单例模式

/*
当前程序在整个程序的运行过程中有且只有一个类对象???
创建，记录，判断，返回
*/

/*
目前问题：
    SingleDog类创建对象可以通过new ＋ 构造方法方式，非常方便
    并且没有任何的约束和限制。
    无法使用语法要求程序员。

解决问题:
    私有化构造方法

又出现了问题：
    类外没有获取对象的方式！！！
分析问题：
    1. 类外没有对象，和对象有关的方法不能使用
    2. 类外需要一个获取对象的方式。

    这里需要一个方法，要求通过类名调用，static修饰
    该方法不能私有化，只能公开，public
    获取当前类对象 SingleDog类
    方法名 getInstance
    形式参数列表 没有
    public static SingleDog getInstance()

又出现了问题：
    没有判断之前是否创建过对应的对象，也没有保存对应空间首地址
分析:
    1. 需要保存第一次创建对象的地址
    2. 判断之前是否存在对象

    需要保存数据，这里需要使用变量
    成员变量：不能用，没有对象
    局部变量：不能用
    静态成员变量：可以使用 getInstance方法也是static修饰的静态成员方法

    private static SingleDog sd = null;

当前这种单例模式是满足一个单线程代码
多线程情况下，会出现对象创建多次的问题

    锁对象选择，一定要是一个符合当前代码要求的唯一对象。
    对应SingleDog类而言???
    类锁是使用Class类对象作为当前代码的锁对象，Class
    类对象对于当前SingleDog类是有明确的唯一性！！！
 */

class SingleDog {

    private static SingleDog sd = null;

    private SingleDog() {
    }

    public static SingleDog getInstance() {
        // 类锁
        synchronized (SingleDog.class) {
            if (null == sd) {
                sd = new SingleDog();
            }
        }
        return sd;
    }
}