1. 第一个线程

import java.util.Random;
public class ThreadDemo {//注意 线程是private的private static class MyThread extends Thread {@Overridepublic void run() {Random random = new Random();while (true) {// 打印线程名称System.out.println(Thread.currentThread().getName());try {// 随机停止运行 0-9 秒Thread.sleep(random.nextInt(10));} catch (InterruptedException e) {e.printStackTrace();}}}}public static void main(String[] args) {MyThread t1 = new MyThread();MyThread t2 = new MyThread();MyThread t3 = new MyThread();t1.start();t2.start();t3.start();Random random = new Random();while (true) {// 打印线程名称System.out.println(Thread.currentThread().getName());try {Thread.sleep(random.nextInt(10));} catch (InterruptedException e) {// 随机停止运行 0-9 秒e.printStackTrace();}}}
}

2. Java创建线程的5种方式

class MyThread1 extends Thread{@Overridepublic void run() {System.out.println("继承Thread类 创建线程");}
}class MyThread2 implements Runnable{@Overridepublic void run() {System.out.println("实现Runnable接口 创建线程");}
}class m{public static void main(String[] args) {MyThread1 t1 = new MyThread1();Thread t2 = new Thread(new MyThread2());Thread t3 = new Thread(){@Overridepublic void run(){System.out.println("内部类创建Thread 子对象");}};Thread t4 = new Thread(new Runnable() {@Overridepublic void run() {System.out.println("内部类实现Runnable接口 创建线程");}});Thread t5 = new Thread(()-> System.out.println("lamba创建runnable"));t1.start();t2.start();t3.start();t4.start();t5.start();}
}

3. 多线程优势代码

public class ThreadAdvantage {// 多线程并不一定就能提高速度，可以观察，count 不同，实际的运行效果也是不同的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();// 利用一个线程计算 a 的值Thread thread = new Thread(new Runnable() {@Overridepublic void run() {int a = 0;for (long i = 0; i < count; i++) {a--;}}});thread.start();// 主线程内计算 b 的值int b = 0;for (long i = 0; i < count; i++) {b--;}// 等待 thread 线程运行结束thread.join();// 统计耗时long end = System.nanoTime();double ms = (end - begin) * 1.0 / 1000 / 1000;System.out.printf("并发: %f 毫秒%n", ms);}private static void serial() {// 全部在主线程内计算 a、b 的值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);}
}

4. 线程的属性

public class ThreadDemo {public static void main(String[] args) {Thread thread = new Thread(() -> {for (int i = 0; i < 10; i++) {try {System.out.println(Thread.currentThread().getName() + ": 我还
活着");Thread.sleep(1 * 1000);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(Thread.currentThread().getName() + ": 我即将死去");});System.out.println(Thread.currentThread().getName() + ": ID: " + thread.getId());System.out.println(Thread.currentThread().getName() + ": 名称: " + thread.getName());System.out.println(Thread.currentThread().getName() + ": 状态: " + thread.getState());System.out.println(Thread.currentThread().getName() + ": 优先级: " + thread.getPriority());System.out.println(Thread.currentThread().getName() + ": 后台线程: " + thread.isDaemon());System.out.println(Thread.currentThread().getName() + ": 活着: " + thread.isAlive());System.out.println(Thread.currentThread().getName() + ": 被中断: " + thread.isInterrupted());thread.start();while (thread.isAlive()) {}System.out.println(Thread.currentThread().getName() + ": 状态: " + thread.getState());}
}

5. 中断线程

1. 使用自定义的变量来作为标志位

示例-1: 使用自定义的变量来作为标志位.

• 需要给标志位上加 volatile 关键字(这个关键字的功能后面介绍).public volatile boolean isQuit = false;

public class ThreadDemo private static class MyRunnable implements Runnable {	public volatile boolean isQuit = false;@Overridepublic void run() {while (!isQuit) {System.out.println(Thread.currentThread().getName()+ ": 别管我，我忙着转账呢!");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(Thread.currentThread().getName()+ ": 啊！险些误了大事");}}public static void main(String[] args) throws InterruptedException {MyRunnable target = new MyRunnable();Thread thread = new Thread(target, "李四");System.out.println(Thread.currentThread().getName()+ ": 让李四开始转账。");thread.start();Thread.sleep(10 * 1000);System.out.println(Thread.currentThread().getName()+ ": 老板来电话了，得赶紧通知李四对方是个骗子！");target.isQuit = true;}
}

2. Thread.interrupted() 或者Thread.currentThread().isInterrupted() 代替自定义标志位

示例-2: 使用 Thread.interrupted() 或者Thread.currentThread().isInterrupted() 代替自定义标志位.

Thread 内部包含了一个 boolean 类型的变量作为线程是否被中断的标记.

方法	说明
public void interrupt()	中断对象关联的线程，如果线程正在阻塞，则以异常方式通知，否则设置标志位
public static boolean interrupted()	判断当前线程的中断标志位是否设置，调用后清除标志位。
public boolean isInterrupted()	判断对象关联的线程的标志位是否设置，调用后不清除标志位

什么叫做清除标志位呢？
就是比如看教室里的灯是否关闭了，如果打开了，清除标志位就是，把灯关了，下次再看就是灯是关的，但第一次看的时候，灯是开得。不清除标志位就表示，不关灯，每次看都是灯是开的

使用 thread 对象的 interrupted() 方法通知线程结束.

public class ThreadDemo {private static class MyRunnable implements Runnable {@Overridepublic void run() {// 两种方法均可以while (!Thread.interrupted()) {//while (!Thread.currentThread().isInterrupted()) {System.out.println(Thread.currentThread().getName()+ ": 别管我，我忙着转账呢!");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();System.out.println(Thread.currentThread().getName()+ ": 有内鬼，终止交易！");// 注意此处的 breakbreak;}}System.out.println(Thread.currentThread().getName()+ ": 啊！险些误了大事");}}public static void main(String[] args) throws InterruptedException {MyRunnable target = new MyRunnable();Thread thread = new Thread(target, "李四");System.out.println(Thread.currentThread().getName()+ ": 让李四开始转账。");thread.start();Thread.sleep(10 * 1000);System.out.println(Thread.currentThread().getName()+ ": 老板来电话了，得赶紧通知李四对方是个骗子！");thread.interrupt();}
}

6. join

2.5 等待一个线程-join()

A中调用B.join表示 B先完成后A再继续

有时，我们需要等待一个线程完成它的工作后，才能进行自己的下一步工作。例如，张三只有等李四转账成功，才决定是否存钱，这时我们需要一个方法明确等待线程的结束

public class ThreadJoin {//样例一
//    public static void main(String[] args) throws InterruptedException {
//        Runnable target = () -> {
//            for (int i = 0; i < 10; i++) {
//                try {
//                    System.out.println(Thread.currentThread().getName()
//                                       + ": 我还在工作！");
//                    Thread.sleep(1000);
//               } catch (InterruptedException e) {
//                    e.printStackTrace();
//               }
//           }
//            System.out.println(Thread.currentThread().getName() + ": 我结束了！");
//       };
//        Thread thread1 = new Thread(target, "李四");
//        Thread thread2 = new Thread(target, "王五");
//        System.out.println("先让李四开始工作");
//        thread1.start();
        thread1.join();
//        System.out.println("李四工作结束了，让王五开始工作");
//        thread2.start();
        thread2.join();
//        System.out.println("王五工作结束了");
//   }//样例二public static void main(String[] args) {Thread t2 = new Thread(()->{for(int i = 1; i <= 10000;i++){System.out.printf("t2工作%d %n",i);}});Thread t1 = new Thread(()->{//t2先工作try {t2.join();} catch (InterruptedException e) {e.printStackTrace();}for(int i = 1; i <= 10000; i++){System.out.printf("t1工作%d %n",i);}});t2.start();t1.start();}
}

7. 观察线程的所有状态（遍历 Thread.State.values()）

线程的状态是一个枚举类型 Thread.State

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

8. 观察线程不安全

static class Counter {public int count = 0;void increase() {count++;}
}
public static void main(String[] args) throws InterruptedException {final 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.count);
}

9. synchronized

//调用increase 就会导致锁两次this 
//但是synchronized是可重入的
public class ThreadSecurity_see {static class Counter {public int count = 0;void increase() {synchronized (this){count++;}}void increase2() {synchronized (this){increase();}}}public static void main(String[] args) throws InterruptedException {Counter counter = new Counter();Thread t1 = new Thread(()->{for(int i = 0; i < 50000; i++){counter.increase2();}System.out.println("t1结束");});Thread t2 = new Thread(()->{for(int i = 0; i < 50000; i++){counter.increase2();}System.out.println("t2结束");});System.out.println("开始");System.out.println(counter.count);t1.start();t2.start();t1.join();t2.join();System.out.println("全部结束");System.out.println(counter.count);}
}

9. volatile

import java.util.Scanner;public class ThreadVolatile {static class Counter {public int flag = 0;}public static void main(String[] args) {Counter counter = new Counter();Thread t1 = new Thread(() -> {while (counter.flag == 0) {// do nothing}System.out.println("循环结束!");});Thread t2 = new Thread(() -> {Scanner scanner = new Scanner(System.in);System.out.println("输入一个整数:");counter.flag = scanner.nextInt();});t1.start();t2.start();}
}// 执行效果
// 当用户输入 非0值 时, t1 线程循环不会结束. (这显然是一个 bug)

• t1 读的是自己工作内存中的内容.
• 当 t2 对 flag 变量进行修改, 此时 t1 感知不到 flag 的变化

如果给 flag 加上 volatile

static class Counter {public volatile int flag = 0; 
}
// 执行效果
// 当用户输入非0值时, t1 线程循环能够立即结束.

volatile 不保证原子性

volatile 和 synchronized 有着本质的区别. synchronized 能够保证原子性, volatile 保证的是内存可见性.

代码示例
这个是最初的演示线程安全的代码

• 给 increase 方法去掉 synchronized
• 给 count 加上 volatile 关键字.

static class Counter {volatile public int count = 0;void increase() {count++;}
}
public static void main(String[] args) throws InterruptedException {final 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.count);
}

此时可以看到, 最终 count 的值仍然无法保证是 100000.

synchronized 也能保证内存可见性

synchronized 既能保证原子性, 也能保证内存可见性
对上面的代码进行调整:

• 去掉 flag 的 volatile
• 给 t1 的循环内部加上 synchronized, 并借助 counter 对象加锁.

static class Counter {public int flag = 0; 
}
public static void main(String[] args) {Counter counter = new Counter();Thread t1 = new Thread(() -> {while (true) {synchronized (counter) {if (counter.flag != 0) {break;}}// do nothing}System.out.println("循环结束!");});Thread t2 = new Thread(() -> {Scanner scanner = new Scanner(System.in);System.out.println("输入一个整数:");counter.flag = scanner.nextInt();});t1.start();t2.start();
}

10. wait和notify

static class WaitTask implements Runnable {private Object locker;public WaitTask(Object locker) {this.locker = locker;}@Overridepublic 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;}@Overridepublic 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();
}

11. 单例模式

class Singleton {private static volatile Singleton instance = null;private Singleton() {}public static Singleton getInstance() {if (instance == null) {synchronized (Singleton.class) {if (instance == null) {instance = new Singleton();}}}return instance;}
}

12. 阻塞队列

BlockingQueue<String> queue = new LinkedBlockingQueue<>();
// 入队列
queue.put("abc");
// 出队列. 如果没有 put 直接 take, 就会阻塞. 
String elem = queue.take();

public static void main(String[] args) throws InterruptedException {BlockingQueue<Integer> blockingQueue = new LinkedBlockingQueue<Integer>();Thread customer = new Thread(() -> {while (true) {try {int value = blockingQueue.take();System.out.println("消费元素: " + value);} catch (InterruptedException e) {e.printStackTrace();}}}, "消费者");customer.start();Thread producer = new Thread(() -> {Random random = new Random();while (true) {try {int num = random.nextInt(1000);System.out.println("生产元素: " + num);blockingQueue.put(num);Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}, "生产者");producer.start();customer.join();producer.join();
}

13. time

public class ThreadTimer {public static void main(String[] args) {// 标准库的定时器.Timer timer = new Timer();timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("时间到, 快起床!");}}, 3000);timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("时间到2!");}}, 4000);timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("时间到3!");}}, 5000);System.out.println("开始计时!");}
}

14. 线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class Demo26 {public static void main(String[] args) {ExecutorService pool = Executors.newCachedThreadPool();pool.submit(new Runnable() {@Overridepublic void run() {System.out.println("这是任务");}});}
}