多线程编程设计模式(单例,阻塞队列,定时器,线程池)（二）

public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        // 通过反射获取到私有的构造方法
        Class<?> c1 = SingleTonLazy.class;
        Constructor<SingleTonLazy> con = (Constructor<SingleTonLazy>) c1.getDeclaredConstructor();
        con.setAccessible(true);
        // 创建出了一个新的实例
        SingleTonLazy s1 = con.newInstance();
        SingleTonLazy s2 = SingleTonLazy.getInstance();
        System.out.println(s1 == s2);// 输出false
    }

public enum SingletonEnum {
    INSTANCE; // 单例实例
    // 可以在枚举类型中添加其他方法或属性
}
public class Demo {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        // 尝试通过反射创建实例
        Class<?> c1 = SingletonEnum.class;
        Constructor<SingletonEnum> con = (Constructor<SingletonEnum>) c1.getDeclaredConstructor(String.class, int.class);
        con.setAccessible(true);
        SingletonEnum s1 = SingletonEnum.INSTANCE;
        SingletonEnum s2 = SingletonEnum.INSTANCE;
        System.out.println(s1 == s2); // 输出true，说明是同一个实例
        // 尝试通过反射创建实例，这里会抛出异常，因为枚举类型无法通过反射实例化
        try {
            SingletonEnum s3 = con.newInstance("someString", 42);
        } catch (Exception e) {
            System.out.println("Exception caught: " + e);
        }
    }
}

public interface BlockingQueue<E> extends Queue<E>

// 都需要指定容量  没有不含参数的构造方法
        BlockingQueue<Integer> queue1 = new ArrayBlockingQueue<>(10);
        BlockingQueue<Integer> queue2 = new LinkedBlockingQueue<>(10);

// 创建一个阻塞队列
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);
        // 生产者线程
        Thread producer = new Thread(() ->{
                try {
                    for (int i = 0; i < 5; i++) {
                      // 向阻塞队列中添加数据
                        queue.put(i);
                        System.out.println("produce:" + i);
                        Thread.sleep(1000);
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
        });
        // 消费者模型
        Thread consumer = new Thread(() ->{
            try {
                for (int i = 0; i < 5; i++) {
                  // 从阻塞队列中获取数据并打印
                    Integer ret = queue.take();
                    System.out.println("consume:" + ret);
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        // 开启两个线程
        producer.start();
        consumer.start();
    }

// 这里采用数组实现  数组内部存放String类型的数据
private String[] elem = new String[100];
private volatile int front;// 指向首元素
private volatile int rear;// 指向尾元素
private volatile int cnt = 0;// 用于判满
// 用于加锁的对象
private Object locker = new Object();

// put 向阻塞队列中存入数据
public void put(String data) throws InterruptedException {
  synchronized(locker) {
    // 如果为满 就要阻塞等待
    // 此处要使用while循环 
    while(cnt == elem.length) {
      // 使用wait进行等待 wait必须搭配synchronized进行使用
      // 直到队列中有元素被take出去 才能进行唤醒
      locker.wait();
      // 被唤醒之后还要再次判断当前队列是否为满
    }
      // 不为空 在队尾存入数据
    this.elem[rear] = data;
    rear = (rear+1) % elem.length;
    cnt++;
    locker.notify();// 用于唤醒take方法中的wait操作
  }
}

// take 从队列中获取对应的数据
public String take() throws InterruptedException {
  synchronized(locker) {
    // 如果为空就阻塞等待  直到有新的元素进入到队列之中
    while(cnt == 0) {
      // 使用wait进行阻塞等待
      // 当有新的元素被添加进入到队列后 就唤醒
      locker.wait();
      // 被唤醒之后还要再次判断当前队列是否为空
    }
      // 不为空 取出数据
    String ret = this.elem[front];
    front = (front+1) % elem.length;
    cnt--;
    locker.notify();// 用于唤醒put方法内部的wait操作
    return ret;
  }
}