Java 多线程系列Ⅳ

public class Singleton {  
    // 在类加载时就实例化对象  
    private static final Singleton instance = new Singleton();  
  
    // 构造函数私有化，防止在其他类中创建此类的实例  
    private Singleton() {}  
  
    // 提供公开的静态方法 getInstance 来获取该单例对象  
    public static Singleton getInstance() {  
        return instance;  
    }  
}

public class Singleton {  
    // 声明一个静态的实例对象，初始化为null  
    private static Singleton instance = null;  
  
    // 构造函数私有化，防止在其他类中创建此类的实例  
    private Singleton() {}  
  
    // 提供一个公共的静态方法 getInstance 来获取该单例对象  
    public static Singleton getInstance() {  
        if (instance == null) {  
            synchronized (Singleton.class) {  
                if (instance == null) {  
                    instance = new Singleton();  
                }  
            }  
        }  
        return instance;  
    }  
}

	public interface UserDao {  

	    public User getUserById(int userId);  

	}  

	public class H2UserDao implements UserDao {  

	    public User getUserById(int userId) {  
	        // 实现具体的逻辑  
	    }  

	}  

	public class MyBatisUserDao implements UserDao {  

	    public User getUserById(int userId) {  
	        // 实现具体的逻辑  
	    }  

	}  

	public class UserDaoFactory {  

	    public static UserDao createUserDao(String type) {  

	        if (type.equalsIgnoreCase("h2")) {  

	            return new H2UserDao();  

	        } else if (type.equalsIgnoreCase("mybatis")) {  

	            return new MyBatisUserDao();  

	        } else {  

	            throw new IllegalArgumentException("Invalid type: " + type);  

	        }  

	    }  

	}

import java.util.concurrent.ArrayBlockingQueue;  
import java.util.concurrent.BlockingQueue;  
  
public class ProducerConsumerExample {  
    public static void main(String[] args) {  
        // 创建一个容量为10的阻塞队列  
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);  
  
        // 创建一个生产者线程和一个消费者线程  
        Thread producer = new Thread(new Producer(queue));  
        Thread consumer = new Thread(new Consumer(queue));  
  
        // 启动线程  
        producer.start();  
        consumer.start();  
    }  
}  
  
class Producer implements Runnable {  
    private BlockingQueue<Integer> queue;  
  
    public Producer(BlockingQueue<Integer> queue) {  
        this.queue = queue;  
    }  
  
    @Override  
    public void run() {  
        try {  
            for (int i = 0; i < 100; i++) {  
                queue.put(i); // 添加元素到队列中，如果队列已满则会被阻塞  
                System.out.println("Producer produced " + i);  
                Thread.sleep(100); // 模拟生产数据的耗时操作  
            }  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
    }  
}  
  
class Consumer implements Runnable {  
    private BlockingQueue<Integer> queue;  
  
    public Consumer(BlockingQueue<Integer> queue) {  
        this.queue = queue;  
    }  
  
    @Override  
    public void run() {  
        try {  
            while (true) {  
                Integer i = queue.take(); // 从队列中获取元素，如果队列为空则会被阻塞  
                System.out.println("Consumer consumed " + i);  
                Thread.sleep(100); // 模拟处理数据的耗时操作  
            }  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
    }  
}

import java.util.Timer;  
import java.util.TimerTask;  
  
public class SimpleTimerTaskExample {  
  
    public static void main(String[] args) {  
        // 创建一个Timer对象  
        Timer timer = new Timer();  
  
        // 创建一个TimerTask对象，这里我们使用匿名内部类的方式创建  
        TimerTask task = new TimerTask() {  
            @Override  
            public void run() {  
                // 这里是定时任务的具体逻辑，这里我们简单打印一条消息  
                System.out.println("执行定时任务");  
            }  
        };  
  
        // 定时器任务每隔1秒执行一次，这里设置的是1000毫秒，即1秒  
        timer.schedule(task, 0, 1000);  
    }  
}

import java.util.PriorityQueue;  
import java.util.concurrent.TimeUnit;  
  
public class Timer {  
    private final PriorityQueue<Task> queue;  
  
    public Timer() {  
        this.queue = new PriorityQueue<>((t1, t2) -> Long.compare(t2.getDelay(), t1.getDelay()));  
    }  
  
    public void schedule(Task task) {  
        queue.add(task);  
    }  
  
    public void run() {  
        while (true) {  
            Task task = queue.poll();  
            if (task == null) break;  
  
            long delay = task.getDelay();  
            try {  
                TimeUnit.SECONDS.sleep(delay); // 等待指定的延迟时间  
                System.out.println("任务执行"); // 执行任务，这里仅仅是打印一条消息，你可以替换为实际的任务执行逻辑  
            } catch (InterruptedException e) {  
                Thread.currentThread().interrupt();   
            }  
        }  
    }  
}  
  
class Task {  
    private final long delay;  
    private final Runnable task;  
  
    public Task(long delay, Runnable task) {  
        this.delay = delay;  
        this.task = task;  
    }  
  
    public long getDelay() {  
        return delay;  
    }  
  
    public void run() {  
        task.run();  
    }  
}

public class MyThreadPool {
    // 管理任务的阻塞队列（本身就是多线程安全）
    private BlockingQueue<Runnable> queue = new LinkedBlockingQueue();
	
	// 添加任务方法
    public void submit(Runnable runnable) throws InterruptedException {
        queue.put(runnable);
    }

    // 实现一个固定线程个数的线程池
    public MyThreadPool(int n) {
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(()->{
                while (true) {
                    try {
                        Runnable runnable = queue.take();
                        runnable.run();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            // 启动线程
            t.start();
        }
    }
}