JavaEE初阶——从入门到掌握线程安全

import java.util.Random;

public class ThreadDemo {
    private static class MyThread extends Thread {
        @Override
        public void run() {
            Random random = new Random();
            while (true) {
                System.out.println(Thread.currentThread().getName());
                try {
                    Thread.sleep(random.nextInt(10));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();

        Random random = new Random();
        while (true) {
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(random.nextInt(10));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

package Thread;

public class Demo5 {
    public static void main(String[] args) {
        // 使用lambda表达式
        Thread thread1 = new Thread(() -> {
            while (true) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }, "thread-1");
        thread1.start();
    }
}

public class ThreadAdvantage {
    private static final long count = 10_0000_0000;

    public static void main(String[] args) throws InterruptedException {
        concurrency();
        serial();
    }

    private static void concurrency() throws InterruptedException {
        long begin = System.nanoTime();
        Thread thread = new Thread(() -> {
            int a = 0;
            for (long i = 0; i < count; i++) a--;
        });
        thread.start();
        int b = 0;
        for (long i = 0; i < count; i++) b--;
        thread.join();
        long end = System.nanoTime();
        double ms = (end - begin) * 1.0 / 1000 / 1000;
        System.out.printf("并发: %f 毫秒%n", ms);
    }

    private static void serial() {
        long begin = System.nanoTime();
        int a = 0;
        for (long i = 0; i < count; i++) a--;
        int b = 0;
        for (long i = 0; i < count; i++) b--;
        long end = System.nanoTime();
        double ms = (end - begin) * 1.0 / 1000 / 1000;
        System.out.printf("串行: %f 毫秒%n", ms);
    }
}

Thread t = new Thread(() -> System.out.println("线程运行"));
t.start(); // 真正启动线程

public class ThreadDemo {
    private static class MyRunnable implements Runnable {
        public volatile boolean isQuit = false;

        @Override
        public void run() {
            while (!isQuit) {
                System.out.println("转账中...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("停止转账");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MyRunnable target = new MyRunnable();
        Thread t = new Thread(target, "李四");
        t.start();
        Thread.sleep(5000);
        target.isQuit = true;
    }
}

package Thread;

//中断线程
//通过调用线程的interrupt()方法，来中断线程
public class Demo8 {
    public static void main(String[] args) throws InterruptedException {
        // 注意，此处针对lambda的定义其实是在new Thread之前的！
        // 所以如果在lambda中使用thread，是会报错的！
        Thread thread = new Thread(() -> {
            // currentThread()是Thread提供的一个静态方法
            // 它的功能是哪个线程调用这个方法，就返回哪个线程对象的引用
            while (!Thread.currentThread().isInterrupted()) {
                // 由于这个 currentThread()方法，是在后续thread.start 之后，才执行的.
                // 并且是在thread线程中执行的。返回的结果就是指向thread线程对象的引用了
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // 如果线程在sleep状态时，被中断了，会触发InterruptedException异常
                    // 当线程thread正在sleep时，主线程（main）调用thread的interrupt方法，可以提前唤醒sleep状态的线程，此时会触发InterruptedException异常。通过这个异常，能区分线程是正常休眠结束还是被提前中断唤醒。并且，当sleep因提前唤醒触发异常后，会将线程的中断标志位（isInterrupted）重置为false。因此会无限循环！

                    // 这个printStackTrace()方法，只是用来打印异常的栈轨迹的。
                    e.printStackTrace();

                    // 当线程在sleep状态时被中断，会抛出InterruptedException异常。我们可以在catch块中处理这个异常，例如记录日志、清理资源等。同时，我们可以根据业务需求，选择是否继续循环或退出线程或稍等一会儿在退出循环。这里我们选择退出线程
                    // 添加break之后，触发异常时就会结束循环，让线程结束
                    // 在break之前也可以添加一些其他善后逻辑,相当于稍后再结束
                    // doSomething();
                    break;

                    // 使用IDEA自动生成catch语句，此时默认给的代码就是再次抛出一个其他异常，如RuntimeException，但是这个做法太粗暴了，它不只是让thread线程结束，也会使整个进程结束，因为没有人catch这个RuntimeException异常。不推荐
                    // throw new RuntimeException(e);

                }
            }
        });
        thread.start();
        // 在main线程中尝试终止thread线程
        Thread.sleep(3000);
        thread.interrupt();
    }
}

package Thread;

//join方法（主线程等thread线程结束）

public class Demo9 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    // e.printStackTrace();
                    break;
                }
            }
        });
        thread.start();

        // 在主线程中就可以对thread线程进行等待
        System.out.println("主线程等待之前");
        // join也有可能触发阻塞，可能会抛出InterruptedException异常
        // 哪个线程调用了join方法，哪个线程就是等的一方，此处是main
        // join前面那个引用，对应的就是线程就是“被等的一方”
        // 此处是main线程等待thread线程结束

        thread.join();
        System.out.println("主线程等待之后");
    }
}

Thread currentThread = Thread.currentThread();
System.out.println(currentThread.getName());

Thread.sleep(1000); // 休眠1秒

public class ThreadState {
    public static void main(String[] args) {
        for (Thread.State state : Thread.State.values()) {
            System.out.println(state);
        }
    }
}

[NEW]
   |
   | start()
   v
[RUNNABLE] <----------------+
   |                        |
   | 获取CPU                 | yield()/时间片用完
   v                        |
[RUNNING] ------------------+
   |
   | sleep()/wait()/join()
   v
[TIMED_WAITING/WAITING]
   |
   | 时间到/notify()/interrupt()
   v
[RUNNABLE] <----------------+
   ^                        |
   |                        | 获取锁
   | 等待锁                 |
   +------------------------+
   |                        |
   v                        |
[BLOCKED] ------------------+
                           
[RUNNING]
   |
   | 执行完毕
   v
[TERMINATED]

package Thread;

//线程安全

public class Demo14 {
    private static int count = 0;

    public static void main(String[] args) throws InterruptedException {

        // 如果把上面的count移到这里，改成局部变量，那么就会出现lambda变量捕获报错。因为他不是final属性
        // int count = 0;

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                count++;
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                count++;
            }
        });
        t1.start();
        t2.start();

        t1.join();
        t2.join();
        System.out.println(count);
    }
}

package Thread;

//加锁和同步

public class Demo15 {
    private static int count = 0;
    private static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                // 进去synchronized代码块加锁,出去synchronized就是解锁
                synchronized (lock) {
                    count++;
                }
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                // 加锁就是把若干个操作“打包为一个原子”，不是说把count++三个指令变成成一个指令，也不是说，这三个指令要在cpu上一口气执行完不会触发调度
                // 加锁会影响到其他加锁线程，而且是加同一个锁的线程
                // 进去synchronized代码块加锁,出去synchronized就是解锁，()括号里面需要填一个对象，这个对象就是锁对象
                // 只有当两个线程竞争同一把锁，才会产生“阻塞”，竞争不同的锁或者只有一个加锁另一个没加锁，则都不会产生“锁冲突、锁竞争”
                synchronized (lock) {
                    count++;
                }
            }
        });
        t1.start();
        t2.start();

        t1.join();
        t2.join();
        System.out.println(count);
    }
}

synchronized (locker) {
    for (int i = 0; i < 50000; i++) {
        count++;
    }
}

for (int i = 0; i < 50000; i++) {
    synchronized (locker) {
        count++;
    }
}

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

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

package Thread;

// 死锁示例
public class Demo17 {
    // 创建两个锁对象
    private static final Object lockA = new Object();
    private static final Object lockB = new Object();

    public static void main(String[] args) {
        // 线程1：先获取lockA，再尝试获取lockB
        Thread thread1 = new Thread(() -> {
            synchronized (lockA) {
                System.out.println("线程1已获取lockA，尝试获取lockB...");
                // 休眠100ms，让线程2有机会获取lockB，增加死锁概率
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lockB) {
                    System.out.println("线程1已获取lockB");
                }
            }
        });

        // 线程2：先获取lockB，再尝试获取lockA（与线程1顺序相反）
        Thread thread2 = new Thread(() -> {
            synchronized (lockB) {
                System.out.println("线程2已获取lockB，尝试获取lockA...");
                // 休眠100ms，让线程1有机会获取lockA，增加死锁概率
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lockA) {
                    System.out.println("线程2已获取lockA");
                }
            }
        });

        // 启动两个线程
        thread1.start();
        thread2.start();
        System.out.println("线程1和线程2已启动");
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程1和线程2已执行完毕");
    }
}

        // 针对一把锁连续加锁两次（锁的可重入性，避免死锁）
        Thread thread3 = new Thread(() -> {
            synchronized (counter) {
                synchronized (counter) {
                    for (int i = 0; i < 50000; i++) {
                        counter.add();
                    }
                }
            }
        });

public class VolatileDemo {
    static class Counter {
        public volatile int flag = 0;
    }

    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            while (counter.flag == 0) {
                // 空循环
            }
            System.out.println("循环结束");
        });
        Thread t2 = new Thread(() -> {
            Scanner scanner = new Scanner(System.in);
            System.out.println("输入整数:");
            counter.flag = scanner.nextInt();
        });
        t1.start();
        t2.start();
    }
}

package Thread;

import java.util.Scanner;

//wait和notify的使用

public class Demo21 {
    private static Object locker = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            System.out.println("t1 wait之前");
            synchronized (locker) {
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("t1 wait之后");
        });

        Thread t2 = new Thread(() -> {
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入任意内容，唤醒t1线程：");
            scanner.next();
            synchronized (locker) {
                locker.notify();
            }
        });
        t1.start();
        t2.start();
    }
}

package Thread;

//单例模式————>饿汉模式

//Singleton就是单例的意思
class Singleton {
    // 把这个唯一的实例先创建出来
    // 由于此处的instance是一个static的，所以它会在类加载的时候就被创建出来（程序一启动时）
    private static Singleton instance = new Singleton();

    // 提供一个静态的方法，返回这个唯一的实例
    public static Singleton getInstance() {
        return instance;
    }

    // 核心操作：把构造方法私有化，防止外部直接new
    private Singleton() {

    }
}

public class Eager_Initialization {
    public static void main(String[] args) {
        // 做了一个君子协定，你必须通过getInstance()方法来获取实例,而不能直接new
        // 如果有人不会遵守上述决定，那就打破单例了
        // 所以要做一些措施
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        // Singleton s3 = new Singleton();
        System.out.println(s1 == s2);
    }
}

package Thread;

//单例模式————>懒汉模式

class SingletonLazy {
    private static SingletonLazy instance = null;
    // 添加volatile为了不使编译器进行优化，防止触发指令重排序
    private static volatile Object locker = new Object();

    private SingletonLazy() {
        // 防止通过反射破坏单例
        if (instance != null) {
            throw new RuntimeException("不能通过反射创建实例！");
        }
        System.out.println("SingletonLazy构造方法被调用");
    }

    // 提供一个静态的方法，返回这个唯一的实例
    public static SingletonLazy getISingletonLazy() {
        // 先判断是否已经创建了实例
        if (instance == null) {
            synchronized (locker) {
                if (instance == null) {
                    // 如果没有创建实例，就创建一个
                    instance = new SingletonLazy();
                }
            }
        }
        return instance;
    }
}

public class Lazy_Initialization {
    public static void main(String[] args) {

        SingletonLazy s1 = SingletonLazy.getISingletonLazy();
        SingletonLazy s2 = SingletonLazy.getISingletonLazy();
        // Singleton s3 = new Singleton();
        System.out.println(s1 == s2);
    }
}

public class BlockingQueue {
    private final int[] items;
    private int head = 0;
    private int tail = 0;
    private int size = 0;

    public BlockingQueue(int capacity) {
        items = new int[capacity];
    }

    public synchronized void put(int value) throws InterruptedException {
        while (size == items.length) {
            wait();
        }
        items[tail] = value;
        tail = (tail + 1) % items.length;
        size++;
        notifyAll();
    }

    public synchronized int take() throws InterruptedException {
        while (size == 0) {
            wait();
        }
        int value = items[head];
        head = (head + 1) % items.length;
        size--;
        notifyAll();
        return value;
    }
}

package Thread;

import java.util.PriorityQueue;

// 自己实现的定时器
// 定时器要同时管理多个任务
// 有一定的数据结构来管理多个任务
// 使用优先级队列（堆）

// 由于我们把这个类要放在优先级队列中，就需要指定优先级队列的“比较规则“
class MyTimerTask implements Comparable<MyTimerTask> {
    private Runnable task;
    // 这个地方为了和当前时间进行对比，确认这个任务是否要执行，保存时间戳更方便
    private long time;

    public MyTimerTask(Runnable task, long delay) {
        this.task = task;
        // 把delay转换成要执行任务的绝对时间戳记录下来
        this.time = System.currentTimeMillis() + delay;
    }

    public Runnable getTask() {
        return task;
    }

    public long getTime() {
        return time;
    }

    @Override
    public int compareTo(MyTimerTask o) {
        // this - o就会实现一个小堆的效果
        // o - this就会实现一个大堆的效果
        // 这里我们要实现的是谁时间小，就先执行谁
        return (int) (this.time - o.time);
    }
}

class MyTimer {

    private PriorityQueue<MyTimerTask> queue = new PriorityQueue<>();
    private Object locker = new Object();

    // 创建一个构造方法
    public MyTimer() {
        // 我们在这里要创建一个线程，让这个线程去检测是否到时间了，以及去执行这个任务
        Thread thread = new Thread(() -> {
            // 循环从队列中取出元素，然后来判定这个任务的时间是否到达
            // 如果到达就执行任务，并且出队列
            // 如果没到达时间，就暂时不执行
            try {
                while (true) {
                    synchronized (locker) {
                        // 判断队列是否为空
                        if (queue.isEmpty()) {
                            // 如果不处理会触发”忙等“问题，因为线程会一直占用CPU资源
                            // 所以我们要让线程进入等待状态，等下一次被唤醒
                            locker.wait();
                        }
                        // 取出队首元素
                        MyTimerTask task = queue.peek();
                        // 记录当前时刻的时间戳
                        long currentTime = System.currentTimeMillis();
                        // 判断是否到达时间
                        if (task.getTime() > currentTime) {
                            // 时间还没到，也会触发忙等，等待到时间再执行
                            // 这里的wake要处理两种情况
                            // 1. 随时有新任务加入，导致队首元素发生变化
                            // 2. 如果没有新任务，时间到了，线程被唤醒

                            // 如：任务是 14:30，就 wait 30 分钟
                            // 在这 30 分钟过程中,如果没有任何新的任务到来,30 分钟时间到,就应该被唤醒,进而去执行任务~~
                            // 如果在 30 分钟过程中,有新任务来了.新任务是 14:15 分的任务~~此时必然要把 wait 30 分钟唤醒, 根据最新的任务的时间,重新设定
                            // wait 时间.
                            // 如果在 30 分钟过程中,有新任务来了,新任务是 15:00 的任务虽然 wait 暂时唤醒了一下,还是依据 14:30 的任务,重新设置等待时间~~
                            locker.wait(task.getTime() - currentTime);
                        } else {
                            // 执行任务
                            task.getTask().run();
                            // 出队列
                            queue.poll();
                        }
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        thread.start();
    }

    // 创建schedule方法，此处的任务用Runnable表示
    public void schedule(Runnable runnable, long delay) {
        synchronized (locker) {
            queue.offer(new MyTimerTask(runnable, delay));
            locker.notify();
        }
    }

}

public class MyTimerDemo {
    public static void main(String[] args) {
        MyTimer timer = new MyTimer();
        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("定时器执行任务 3000");
            }
        }, 3000);
        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("定时器执行任务 2000");
            }
        }, 2000);
        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("定时器执行任务 1000");
            }
        }, 1000);
    }
}

// 创建包含10个固定线程的线程池
ExecutorService pool = Executors.newFixedThreadPool(10);
// 向线程池提交任务
pool.submit(new Runnable() {
    @Override
    public void run() {
        System.out.println("任务执行：hello");
    }
});

package Thread;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.BlockingQueue;

// 自行实现一个简单的固定线程池
class FixedThreadPool {

    // 创建一个阻塞队列
    private BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>();

    // 创建一个构造方法
    public FixedThreadPool(int n) {
        for (int i = 0; i < n; i++) {
            Thread thread = new Thread(() -> {
                // 每个线程要完成的工作， 就是从队列中取出任务并执行任务
                try {
                    while (true) {
                        Runnable task = queue.take();
                        task.run();
                        // 如果里面没有任务， 就会阻塞在take()方法上
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            thread.start();
        }
    }

    public void sumbit(Runnable task) throws InterruptedException {
        queue.put(task);
    }

}

public class MyFixedThreadPool {
    // 测试创建一个固定线程池
    public static void main(String[] args) throws InterruptedException {
        FixedThreadPool threadPool = new FixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            int id = i;
            threadPool.sumbit(() -> {
                System.out.println("Thread：" + id + " 执行完毕");
            });
        }
    }
}