Java学习之路 —— 多线程

1. 线程创建方式

1.1 继承Thread

定义子类，继承Thread，创建对象，并调用start启动线程

• 优点：编码简单
• 缺点：线程类已经继承Thread，无法继承其他类，不利于功能的扩展

public class Main {// main方法是有一条默认的主线程执行的public static void main(String[] args) {// 1. 创建线程类的对象，代表一个线程Thread t = new MyThread();// 2. 启动线程t.start();for (int i = 0; i < 10000; i++) {System.out.println("主线程输出：" + i);}}
}

注意，是调用Thread的start方法，而不是run方法!!!

public class MyThread extends Thread{@Overridepublic void run() {for (int i = 0; i < 10000; i++) {System.out.println("子线程输出：" + i);}super.run();}
}

1.2 声明一个实现Runnable接口的类

• 优点：只是实现了一个接口，还可以继承一个类，实现其他接口，扩展性强
• 缺点：需要多创建一个Runnable对象

class MyRunnable implements Runnable {@Overridepublic void run() {for (int i = 0; i < 10000; i++) {System.out.println("子线程输出：" + i);}}
}

static void test_Runnable() {
//        Runnable target = new MyRunnable(); // 任务对象（不是线程对象）
//        new Thread(target).start();// lambdanew Thread(() -> {for (int i = 0; i < 10000; i++) {System.out.println("子线程输出：" + i);}for (int i = 0; i < 10; i++) {System.out.println("主线程输出：" + i);}}

1.3 利用Callable接口、FutureTask类来实现

• 优点：可以返回线程执行完后的结果
• 缺点：编码复杂
  

class MyCallable implements Callable<String> {int n;public MyCallable(int n) {this.n = n;}@Overridepublic String call() throws Exception {// 描述线程的任务，返回线程执行后的结果// 求1-n的和int sum = 0;for(int i = 1; i <= n; i++)sum += n;return "1~n的总和是：" + sum;}
}

static void test_Callble() {// 1. 创建Callable对象MyCallable call = new MyCallable(50);// 2. 把Callable对象封装成FutureTask对象// 1. 是一个任务对象，实现了Runnable对象// 2. 可以在线程执行完后，调用get方法获取FutureTask<String> f1 = new FutureTask<>(call);new Thread(f1).start();for (int i = 0; i < 10; i++) {System.out.println("主线程输出：" + i);}// 获取线程执行完毕后的结果String s = null;try {// 会等到线程执行完毕，这行代码再执行s = f1.get();} catch (Exception e) {e.printStackTrace();}System.out.println(s);}

---

我发现啊，Java的多线程和C++的多线程不一样的点是，Java中创建子线程，如果主线程先执行完了，子线程没有执行完，子线程会继续执行；但是C++会被终止。

不过join方法都有着相同的用处，那就是阻塞主线程，等待线程执行完毕后，再执行主线程后面的代码。

2. 线程同步

2.1 同步代码块

synchronized(同步锁) {访问共享资源的核心代码
}

这个同步锁是一个字符串也可以（双引号在内存中存在常量区，只有一份），只要是一个唯一对象即可 。
但最好是用共享资源作为锁，比如说this。

如果要调用静态方法，同步锁采用类名.class，锁住整个class。

2.2 同步方法

把访问共享资源的核心方法上锁，保证线程安全。这样能保证一个对象中，只有一个方法在执行，其他方法都无法执行。

修饰符 synchronized 返回值类型 方法名（形参列表）{操作共享资源得到代码
}

2.3 Lock锁

Lock是一个接口类，可以用实现类ReentrantLock来实例化一个锁，来使用。

Lock lk = new ReentrantLock();
lk.lock();
lk.unlock();

3. 线程同步

来了来了，条件遍历来了。注意，一定要和锁搭配使用。

来一个经典的例子吧，2个线程交替打印A和B

package TestDemo;// 2个线程交替打印A和B10次
public class Test2 {public static int count;static final Object lock = new Object(); // 锁public static void main(String[] args){Thread t1 = new Thread(() -> {for (int i = 0; i < 10; i++) {synchronized (lock) {System.out.println(Thread.currentThread().getName() + "打印A");lock.notify();try {if(i < 9)lock.wait();} catch (Exception e) {e.printStackTrace();}}}}, "A线程");Thread t2 = new Thread(() -> {for (int i = 0; i < 10; i++) {synchronized (lock) {System.out.println(Thread.currentThread().getName() + "打印B");lock.notify();try {if(i < 9)lock.wait();} catch (Exception e) {e.printStackTrace();}}}}, "B线程");t1.start();t2.start();}
}

4. 线程池

JDK5提供了代表线程池的接口：ExecutorService。比较常用的实现类是ThreadPoolExecutor

• public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)
  • corePoolSize：指定线程池的核心线程数量
  • maximumPoolSize：指定线程池的最大线程数量
  • keepAliveTime：指定临时线程的存活时间
  • unit：指定临时线程存货的时间单位
  • workQueue：指定线程池的任务队列
  • threadFactory：指定线程池的任务工厂
  • handler：指定线程池的拒绝策略（任务队列满了后，新任务来了怎么处理）

线程池默认是不会死亡的，除非调用shutdown()，或者shutdownNow()。

1. 临时线程什么时候创建？
   新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程，去执行新任务，而不是任务队列的任务（插队）。
2. 什么时候会开始拒绝新任务？
   核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始拒绝任务。

Executors
是线程池的一个工具类，提供了很多静态方法用于返回不同特点的线程池对象。