【javaEE】多线程（基础）

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running (Thread Class)");
        System.out.println("Thread name: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Thread is running (Runnable)");
        System.out.println("Thread name: " + Thread.currentThread().getName());
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start(); // 启动线程
    }
}

public class Main {
    public static void main(String[] args) {
        // 使用匿名内部类继承 Thread
        Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println("Thread is running (Thread - Anonymous Inner Class)");
                System.out.println("Thread name: " + Thread.currentThread().getName());
            }
        };

        // 启动线程
        thread.start();
    }
}

public class Main {
    public static void main(String[] args) {
        // 使用匿名内部类实现 Runnable
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread is running (Runnable - Anonymous Inner Class)");
                System.out.println("Thread name: " + Thread.currentThread().getName());
            }
        };

        // 创建线程并启动
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

public class Main {
    public static void main(String[] args) {
        // 使用 Lambda 表达式实现 Runnable
        Runnable runnable = () -> {
            System.out.println("Thread is running (Runnable - Lambda Expression)");
            System.out.println("Thread name: " + Thread.currentThread().getName());
        };

        // 创建线程并启动
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    System.out.println("Thread is running...");
                    Thread.sleep(1000); // 线程休眠 1 秒
                } catch (InterruptedException e) {
                    System.out.println("Thread was interrupted while sleeping!");
                    // 恢复中断状态
                    Thread.currentThread().interrupt();
                }
            }
            System.out.println("Thread was interrupted!");
        });

        thread.start();

        // 主线程休眠 3 秒后中断子线程
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread.interrupt(); // 中断子线程
    }
}

Thread is running...
Thread is running...
Thread was interrupted while sleeping!
Thread was interrupted!

class Counter{
    private int count = 0;
    public void increase(){
        count++;
    }
 
    public int getCount() {
        return count;
    }
}
public class Test4 {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                counter.increase();
            }
        });
 
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                counter.increase();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(counter.getCount());
    }
}

class Counter{
    private int count = 0;
    synchronized public void increase(){
        count++;
    }
 
     public int getCount() {
        return count;
    }
}
public class Test4 {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                counter.increase();
            }
        });
 
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 50000; i++) {
                counter.increase();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(counter.getCount());
    }
}

public class Counter {
    private int count = 0;
    private final Object lock = new Object(); // 锁对象

    public void increment() {
        synchronized (lock) { 
            count++;
        }
    }

    public int getCount() {
        return count;
    }
}

​
public class Counter {
    private int count = 0;

    
    public synchronized void increment() {
        count++;
    }//该代码约等于如下代码
 
      public  void increment() {
       synchronized（this）{
        count++;
    }
}
 

    public int getCount() {
        return count;
    }
}

​

​
​
public class Counter {
    private int count = 0;

    
    public static synchronized void increment() {
        count++;
    }//该代码约等于如下代码
 
      public static void increment() {
       synchronized（Counter.class）{
        count++;
    }
}
 

    public int getCount() {
        return count;
    }
}

​

​

static class Counter {
    public int count = 0;
    synchronized void increase() {
        count++;
   }
    synchronized void increase2() {
        increase();
   }
}

public class NestedLockDeadlock {
    // 定义两个锁对象
    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();

    // 线程1：先获取lock1，再获取lock2
    public static void thread1() {
        synchronized (lock1) { // 获取lock1
            System.out.println("Thread 1: Acquired lock1");
            try {
                Thread.sleep(100); // 模拟一些操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lock2) { // 尝试获取lock2
                System.out.println("Thread 1: Acquired lock2");
            }
        }
    }

    // 线程2：先获取lock2，再获取lock1
    public static void thread2() {
        synchronized (lock2) { // 获取lock2
            System.out.println("Thread 2: Acquired lock2");
            try {
                Thread.sleep(100); // 模拟一些操作
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lock1) { // 尝试获取lock1
                System.out.println("Thread 2: Acquired lock1");
            }
        }
    }

    public static void main(String[] args) {
        // 创建两个线程
        Thread t1 = new Thread(NestedLockDeadlock::thread1);
        Thread t2 = new Thread(NestedLockDeadlock::thread2);

        // 启动线程
        t1.start();
        t2.start();
    }
}

public class ThreadDemon26 {
    public static int flag = 0;
 
    public static void main(String[] args) {
 
        Thread t1 = new Thread(()->{
            while(flag == 0){//等待t1线程输入flag的值，只要不为0就能结束t1线程
 
            }
            System.out.println("t1线程结束");
        });
        Thread t2 = new Thread(()->{
            System.out.println("请输入flag的值");
            Scanner scanner = new Scanner(System.in);
            flag = scanner.nextInt();
        });
 
        t1.start();
        t2.start();
    }
}

static class WaitTask implements Runnable {
    private Object locker;
    public WaitTask(Object locker) {
     this.locker = locker;
   }
    @Override
    public void run() {
        synchronized (locker) {
            while (true) {
                try {
                    System.out.println("wait 开始");
                    locker.wait();
                    System.out.println("wait 结束");
               } catch (InterruptedException e) {
                    e.printStackTrace();
               }
           }
       }
   }
}
static class NotifyTask implements Runnable {
    private Object locker;
    public NotifyTask(Object locker) {
        this.locker = locker;
   }
    @Override
    public void run() {
        synchronized (locker) {
            System.out.println("notify 开始");
            locker.notify();
            System.out.println("notify 结束");
       }
   }
}
public static void main(String[] args) throws InterruptedException {
    Object locker = new Object();
    Thread t1 = new Thread(new WaitTask(locker));
    Thread t2 = new Thread(new NotifyTask(locker));
    t1.start();
    Thread.sleep(1000);
    t2.start();
}

​
static class WaitTask implements Runnable {
    private Object locker;
    public WaitTask(Object locker) {
     this.locker = locker;
   }
    @Override
    public void run() {
        synchronized (locker) {
            while (true) {
                try {
                    System.out.println("wait 开始");
                    locker.wait();
                    System.out.println("wait 结束");
               } catch (InterruptedException e) {
                    e.printStackTrace();
               }
           }
       }
   }
}
static class NotifyTask implements Runnable {
    private Object locker;
    public NotifyTask(Object locker) {
        this.locker = locker;
   }
    @Override
    public void run() {
        synchronized (locker) {
            System.out.println("notify 开始");
            locker.notifyall();
            System.out.println("notify 结束");
       }
   }
}
public static void main(String[] args) throws InterruptedException {
   Object locker = new Object();
    Thread t1 = new Thread(new WaitTask(locker));
    Thread t3 = new Thread(new WaitTask(locker));
    Thread t4 = new Thread(new WaitTask(locker));
    Thread t2 = new Thread(new NotifyTask(locker));
    t1.start();
    t3.start();
    t4.start();
    Thread.sleep(1000);
    t2.start();
}

​

public class Singleton{
    
    private static final Singleton singleton = new Singleton();
    
    private Singleton(){}
    
    public static Singleton getInstance() {
        return singleton;
    }
}

public class Singleton {
    
    private static Singleton singleton;
    
    private Singleton(){}
    
    public static Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
    
}

public static synchronized Singleton getInstance() {
    if (singleton == null) {
        singleton = new Singleton();
    }
    return singleton;
}
// 或者
public static Singleton getInstance() {
    synchronized(Singleton.class) {   
        if (singleton == null) {
            singleton = new Singleton();
        }
    }
    return singleton;
}

public static Singleton getInstance() {
    if (singleton == null) {  // 线程A和线程B同时看到singleton = null，如果不为null，则直接返回singleton
        synchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化
            if (singleton == null) { // 其中一个线程进入该分支，另外一个线程则不会进入该分支
                singleton = new Singleton();
            }
        }
    }
    return singleton;
}

public class Singleton {
    
    private static volatile Singleton singleton;
    
    private Singleton(){}
    
    public static Singleton getInstance() {
        if (singleton == null) {  // 线程A和线程B同时看到singleton = null，如果不为null，则直接返回singleton
            synchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化
                if (singleton == null) { // 其中一个线程进入该分支，另外一个线程则不会进入该分支
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
    
}

class MyBlockingQueue {
    //对象公用锁
    private Object lock = new Object();
    //String类型的数组，存储队列元素
    private String[] elems = null;
    //队首位置
    private int head = 0;
    //队尾位置
    private int tail = 0;
    //存储的元素个数
    private int size = 0;
    
    //构造方法，用于构建定长数组，数组长度由参数指定
    public MyBlockingQueue(int capacity) {
        elems = new String[capacity];
    }
 
    //入队方法
    public void put(String elem) throws InterruptedException {
        synchronized(lock) {
            //已满时入队操作阻塞
            while(size == elems.length) {
                lock.wait();
            }
            //将元素存入队尾
            elems[tail] = elem;
            //存入后，队尾位置后移一位
            tail++;
            //实现环形队列的关键，超过数组长度后回归数组首位
            if(tail >= elems.length) {
                //回归数组首位
                tail = 0;
            }
            //存入后元素总数加一
            size++;
            //当出队操作阻塞时，入队后为其解除阻塞
            //（入队后队列不为空了）
            lock.notify();
        }
    }
    
    //出队方法
    public String tack() throws InterruptedException {
        //存储取出的元素，默认为null
        String elem = null;
        synchronized (lock) {
            //队列为空时出队操作阻塞
            while (size == 0) {
                lock.wait();
            }
            //出队，取出队首值（不用置空，队尾存入时覆盖）
            elem = elems[head];
            //出队后，队首位置后移一位
            head++;
            //实现环形队列的关键，超过数组长度后回归数组首位
            if(head == elems.length) {
                //回归数组首位
                head = 0;
            }
            //存入后元素总数加一
            size--;
            //当入队操作阻塞时，出队后为其解除阻塞
            //（出队后队列不满）
            lock.notify();
        }
        //返回取出的元素
        return elem;
    }
}

class MyBlockingQueue {

    private String[] elems = null;

    private volatile int head = 0;

    private volatile int tail = 0;

    private volatile int size = 0;


    public MyBlockingQueue(int capacity) {
        elems = new String[capacity];
    }
 

    public synchronized void  put(String elem)  {

        while(size == elems.length) {
            try{
                this.wait();
            }catch (Exception e)
            {
                e.printStackTrace();
            }
        }
        elems[tail] = elem;

        tail++;

        if(tail >= elems.length) {

            tail = 0;
        }

        size++;
        this.notify();

    }
 

    public synchronized String take()  {
        String elem = null;

        while(size == 0) {
            try{
                this.wait();
            }catch (Exception e)
            {
                e.printStackTrace();
            }
        }

        elem = elems[head];

        head++;

        if(head == elems.length) {

            head = 0;
        }

        size--;
        this.notify();

        return elem;
    }
}
class ThreadDemo5 {
    public static void main(String[] args) throws InterruptedException {
        MyBlockingQueue myBlockingQueue = new MyBlockingQueue(100);
        Thread customer = new Thread(()->{
            while (true) {
                try {
                    String elem = myBlockingQueue.take();
                    System.out.println("消费元素:-> " + elem);
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"消费者");
        Thread producer = new Thread(()->{
            int n = 0;
            while (true) {
                try {
                    myBlockingQueue.put(n + "");
                    System.out.println("生产元素:-> " + n);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
                n++;
            }
        },"生产者");
        // 启动生产者与消费者线程
        customer.start();
        producer.start();
    }
}

Timer timer = new Timer();
timer.schedule(new TimerTask() {
    @Override
    public void run() {
        System.out.println("hello");
   }
}, 3000);

import java.util.PriorityQueue;

class MyTimerTask implements Comparable<MyTimerTask> {
    //此处这里的 time，通过毫秒时间戳，表示这个任务具体啥时候执行
    private long time;
    private Runnable runnable;

    public MyTimerTask(Runnable runnable, long delay) {
        this.time = System.currentTimeMillis() + delay;
        this.runnable = runnable;
    }

    public void run() {
        runnable.run();
    }

    public long getTime() {
        return time;
    }

    @Override
    public int compareTo(MyTimerTask o) {
        //比如，当前时间是 10:30，任务时间是 12:00，不应该执行
        //如果当前时间是 10:30，任务时间是 10:29，应该执行
        //谁减去谁，可以通过实验判断
        return (int) (this.time - o.time);
    }
}

public class MyTimer {
    private final PriorityQueue<MyTimerTask> queue = new PriorityQueue<>();
    private final Object locker = new Object();

    public MyTimer() {
        Thread t = new Thread(() -> {
            try {
                while (true) {
                    synchronized (locker) {
                        while (queue.isEmpty()) {
                            //如果还没添加任务，会不断循环执行判断，出现线程饿死。
                            //continue;
                            //因此，使用wait等待，当添加任务后唤醒
                            locker.wait();
                        }
                        MyTimerTask task = queue.peek();
                        if (System.currentTimeMillis() >= task.getTime()) {
                            task.run();
                            queue.poll();
                        } else {
                            //如果还没到任务执行时间，依旧不断循环判断，出现线程饿死。
                            //continue;
                            //因此，使用有等待期限的 wait，计算执行的时间与当前时间的差值
                            //当添加新的任务后，wait 被唤醒，再进行新的判断
                            locker.wait(task.getTime() - System.currentTimeMillis());
                        }
                    }

                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t.start();
    }

    public void schedule(Runnable runnable, long delay) {
        synchronized (locker) {
            MyTimerTask task = new MyTimerTask(runnable, delay);
            queue.offer(task);
            // 唤醒 wait
            locker.notify();
        }
    }
}

​
​
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);

        // 创建一个可缓存的线程池（线程数量动态调整）
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

    }
}

​

​

 ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                2,  // 核心线程数
                4,  // 最大线程数
                60,  // 空闲线程存活时间
                TimeUnit.SECONDS,  // 时间单位
                new ArrayBlockingQueue<>(10),  // 任务队列，容量为 10
                Executors.defaultThreadFactory(),  // 线程工厂
                new ThreadPoolExecutor.AbortPolicy()  // 拒绝策略
        );

ExecutorService pool = Executors.newFixedThreadPool(10);
pool.submit(new Runnable() {
    @Override
    public void run() {
        System.out.println("hello");
   }
});

/**
 * 自定义线程池执行器类
 * 该类通过实现一个具有固定大小的线程池和一个阻塞队列来管理线程，用于异步执行任务
 */
class MyThreadPoolExecutor {
    // 创建阻塞队列，用于存放待执行的任务
    // 队列大小设为1000，用于控制并发任务的数量，避免过多任务导致资源耗尽
    BlockingQueue<Runnable>  blockingQueue=new ArrayBlockingQueue<>(1000);
 
    /**
     * 构造函数，初始化线程池
     * 创建一个线程，该线程循环从阻塞队列中取任务并执行
     * 这个线程是线程池中的工作线程，负责执行提交的任务
     */
    public MyThreadPoolExecutor(int n) {
        for (int i = 1; i <= n; i++) {
            Thread t = new Thread(() -> {
                // 无限循环，确保线程池可以持续处理任务，直到程序中断或阻塞队列被清空
                while (true) {
                    try {
                        // 从阻塞队列中取出一个任务，如果队列为空，则线程被阻塞，直到有任务放入队列
                        Runnable task = blockingQueue.take();
                        // 执行取出的任务
                        task.run();
                    } catch (InterruptedException e) {
                        // 如果线程在等待状态时被中断，抛出运行时异常
                        // 这通常会导致程序异常终止
                        throw new RuntimeException(e);
                    }
                }
            });
            // 启动线程池中的工作线程
            t.start();
        }
    }
 
     /**
      * 提交一个任务到线程池
      * @param task 需要被执行的任务
      *            任务被放入阻塞队列中，随后由线程池中的工作线程执行
      */
     public void submit(Runnable task){
         // 将任务放入阻塞队列，如果队列已满，则操作会阻塞，直到有空间可用
         blockingQueue.offer(task);
     }
}
class DemoTest1{
    public static void main(String[] args) throws InterruptedException {
       MyThreadPoolExecutor ex=new MyThreadPoolExecutor(4);
       for(int i=0;i<100;i++) {
           int id = i;
           ex.submit(()->{
               System.out.println(Thread.currentThread().getName()+"  任务:"+id);
           });
       }
    }
}