多线程

1. 关于多线程的理解

1.1 进程和线程

每个进程有多个线程

• 进程是系统运行程序的基本单元
• 每个进程的内部数据和状态是完全独立的
• 每一个应用程序运行的时候会产生一个进程
• 线程：就是一个进程中的执行单元。一个进程可以启动多个线程。cpu 调度和分配的最小单元。
• 线程必须在某个进程内执行。

所以多线程就是：在一个进程中同时运行了多个线程，用来完成不同的工作，则称之为多线程。

• 进程与线程的区别
  • 进程：有独立的内存空间，进程中的数据存放空间（堆空间和栈空间）是独立的，至少
    有一个线程。
  • 线程：堆空间是共享的，栈空间是独立的，线程消耗的资源比进程小的多。

1.2 并行和并发

1. 并发（Concurrency）：

   • 并发是指多个任务在相同的时间段内交替执行，每个任务可能只执行一小部分，然后切换到另一个任务。
   • 并发并不一定意味着多个任务同时在不同的处理器核心上执行。它可以在单个处理器上通过时间片轮转来实现，也可以在多个处理器核心上并行执行。
   • 通常，多线程程序是并发的，因为它们可以在单个处理器上通过线程切换实现并发执行。

   示例：多个线程在单个处理器上轮流执行，共享CPU时间。

2. 并行（Parallelism）：

   • 并行是指多个任务在相同的时间点上同时执行，每个任务都在不同的处理器核心上运行。
   • 并行通常需要多核处理器或多个计算资源，并且可以实现更高的性能，因为多个任务可以在不互相干扰的情况下并行执行。
   • 并行通常用于解决需要高性能的问题，如大规模数据处理或计算密集型任务。

   示例：多个线程在不同的处理器核心上同时执行，各自独立工作。

总结：

• 并发是任务在时间上交替执行，可能在同一处理器核心上通过线程切换实现。
• 并行是任务在同一时刻同时执行，通常需要多个处理器核心或多个计算资源来实现。
• 并发可以提高系统的响应性和资源利用率，但并不一定提高吞吐量。
• 并行通常用于提高性能，特别是在多核处理器上，可以实现更高的吞吐量

1.3 线程调度

每个程序至少自动拥有一个线程，称为主线程

1. 分时调度
   所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

2. 抢占式调度

   优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)， Java 使用的为抢占式调度。

2. 创建多线程的方式

创建线程有哪几种方式？

创建线程有三种方式，分别是继承Thread类、实现Runnable接口、实现Callable接口。

2.1 通过继承Thread类来创建并启动线程的步骤如下：

1. 定义Thread类的子类，并重写该类的run()方法，该run()方法将作为线程执行体。

2. 创建Thread子类的实例，即创建了线程对象。

3. 调用线程对象的start()方法来启动该线程。

/*** 实现多线程的第一种方式*      第一种方式：编写一个类，直接继承java.lang.Thread，重写run方法*/
public class ThreadDemo01 {public static void main(String[] args) {System.out.println("main start!");MyThread myThread = new MyThread();myThread.test();        // 不会启动线程// 只有调用s'tartmyThread.start();for (int i = 0; i < 10; i++) {System.out.println("main线程");}}
}
// 自定义线程类
class MyThread extends Thread{@Overridepublic void run(){Thread thread = Thread.currentThread();     // 获取当前线程thread.setName("自定义线程");    // 设置当前线程的名字String name = thread.getName();     // 获取当前线程的名字for (int i = 0; i < 10; i++) {System.out.println(name + i);}}public void test(){System.out.println("test");}
}

2.2 通过实现Runnable接口来创建并启动线程的步骤如下：

1. 定义Runnable接口的实现类，并实现该接口的run()方法，该run()方法将作为线程执行体。
2. 创建Runnable实现类的实例，并将其作为Thread的target来创建Thread对象，Thread对象为线程对象。
3. 调用线程对象的start()方法来启动该线程。

/*** 实现多线程的第二种方式*      第二种方式：编写一个类，实现java.lang.Runnable接口*/
public class ThreadDemo02 {public static void main(String[] args) {// 创建任务对象MyRunnable myRunnable = new MyRunnable();// 创建线程Thread tr = new Thread(myRunnable,"线程1");// 启动线程tr.start();System.out.println("主线程");// 除了上面使用的自定义类实现Runnable接口之外，还可以使用匿名内部类、lambda表达式来实现Runnable接口Runnable runnable1 = new Runnable() {@Overridepublic void run() {System.out.println("使用匿名内部类实现Runnable接口。。");}};new Thread(runnable1).start();Runnable runnable2 = ()->{String name = Thread.currentThread().getName();System.out.println(name + ":使用匿名内部类实现Runnable接口。。");};new Thread(runnable2).start();}
}
// 自定义类实现 Runnable 接口
class MyRunnable implements Runnable{@Overridepublic void run() {String name = Thread.currentThread().getName();System.out.println(name + "实现线程的第二种方式.");}
}

2.3 通过实现Callable接口来创建并启动线程的步骤如下：

1. 创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，且该call()方法有返回值。然后再创建Callable实现类的实例。
2. 使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
3. 使用FutureTask对象作为Thread对象的target创建并启动新线程。
4. 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

/*** 创建线程的第三种方式：*      实现Callable接口*/
public class ThreadDemo03 {public static void main(String[] args) throws ExecutionException, InterruptedException {// 使用匿名内部类实现Callable接口Callable<Integer> callable = new Callable<>() {@Overridepublic Integer call() throws Exception {int sum = 0;for (int i = 1; i < 10; i++) {sum += i;}// 返回一个结果return sum;}};// 创建一个FutureTask 对象，来接受异步计算的结果FutureTask<Integer> futureTask = new FutureTask<>(callable);// 创建线程Thread thread = new Thread(futureTask);thread.start();// futureTask.get() 是在等待执行完毕获取结果，所以是在线程启动之后，才获取。System.out.println(futureTask.get());}
}

采用继承Thread类的方式、实现Runnable、Callable接口的方式创建多线程的优缺点：

• 线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。而如果是已经继承Thread 类，则不能再继承其它父类了。（所以实现接口可以避免 java 中的单继承的局限性）
• 在实现Runnable、Callable接口的这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同的程序代码的线程去共享同一个资源的情况，实现解耦操作，较好地体现了面向对象的思想。
• 线程池只能放入实现 Runnable 或 Callable 类线程，不能直接放入继承 Thread 的类
• 劣势是，编程稍稍复杂，如果需要访问当前线程，则必须使用Thread.currentThread()方法。
• 采用继承Thread类的方式创建多线程的优势是，编写简单，如果需要访问当前线程，则无须使用Thread.currentThread()方法，直接使用this即可获得当前线程。
  鉴于上面分析，因此一般推荐采用实现Runnable接口、Callable接口的方式来创建多线程。

3 run()和start()有什么区别？

run()方法被称为线程执行体，它的方法体代表了线程需要完成的任务，而start()方法用来启动线程。调用start()方法启动线程时，系统会把该run()方法当成线程执行体来处理。但如果直接调用线程对象的run()方法，则run()方法立即就会被执行，而且在run()方法返回之前其他线程无法并发执行。也就是说，如果直接调用线程对象的run()方法，系统把线程对象当成一个普通对象，而run()方法也是一个普通方法，而不是线程执行体。

4 线程是否可以重复启动，会有什么后果？

只能对处于新建状态的线程调用start()方法，否则将引发IllegalThreadStateException异常。

扩展阅读

当程序使用new关键字创建了一个线程之后，该线程就处于新建状态，此时它和其他的Java对象一样，仅仅由Java虚拟机为其分配内存，并初始化其成员变量的值。此时的线程对象没有表现出任何线程的动态特征，程序也不会执行线程的线程执行体。

当线程对象调用了start()方法之后，该线程处于就绪状态，Java虚拟机会为其创建方法调用栈和程序计数器，处于这个状态中的线程并没有开始运行，只是表示该线程可以运行了。至于该线程何时开始运行，取决于JVM里线程调度器的调度。

5. 说一说sleep()和wait()的区别

1. sleep()是Thread类中的静态方法，而wait()是Object类中的成员方法；
2. sleep()可以在任何地方使用，而wait()只能在同步方法或同步代码块中使用；
3. sleep()不会释放锁，而wait()会释放锁，并需要通过notify() / notifyAll()重新获取锁。

6. 说一说notify()、notifyAll()的区别

• notify()

  用于唤醒一个正在等待相应对象锁的线程，使其进入就绪队列，以便在当前线程释放锁后竞争锁，进而得到CPU的执行。

• notifyAll()

  用于唤醒所有正在等待相应对象锁的线程，使它们进入就绪队列，以便在当前线程释放锁后竞争锁，进而得到CPU的执行。

7. 如何实现子线程先执行，主线程再执行？

启动子线程后，立即调用该线程的join()方法，则主线程必须等待子线程执行完成后再执行。

扩展阅读

Thread类提供了让一个线程等待另一个线程完成的方法——join()方法。当在某个程序执行流中调用其他线程的join()方法时，调用线程将被阻塞，直到被join()方法加入的join线程执行完为止。

join()方法通常由使用线程的程序调用，以将大问题划分成许多小问题，每个小问题分配一个线程。当所有的小问题都得到处理后，再调用主线程来进一步操作。

8. Thread 类的方法

8.1 构造方法

Thread中常用的构造方法有：

• public Thread() :分配一个新的线程对象。
• public Thread(String name) :分配一个指定名字的新的线程对象。
• public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
• public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

8.2 Thread 类的常用方法

1. public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

   Thread.currentThread(); // 执行这句代码的线程
   

2. public void run(): 表示线程的任务。

   • 所有Thread的子类应该覆盖（重写）此方法

3. public synchronized void start(): 线程开始执行;

   • 多次调用同一个线程的此方法是不合法的。

4. public static native void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性。 线程不会丢失任何CPU的所有权。

   //线程休眠5S
   Thread.sleep(5000);	
   

5. public static void sleep(long millis, int nanos) :使当前正在执行的线程以指定的毫秒数加上指定的纳秒数暂停（暂时停止执行）

6. public final String getName():返回此线程的名称

   Thread.currentThread().getName();//获取当前线程名称
   

7. public final synchronized void setName(String name):将此线程的名称更改为等于参数name

8. public final int getPriority():返回此线程的优先级

9. public final void setPriority(int newPriority):更改此线程的优先级,1~10之间

10. public final native boolean isAlive():测试这个线程是否活着。 如果一个线程已经启动并且尚未死亡，那么线程是活着的

public static void main(String[] args) {Runnable runnable = new Runnable() {@Overridepublic void run() {for (int i = 0; i < 3; i++) {try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}};Thread thread = new Thread(runnable);// isAlive()：测试这个线程是否活着System.out.println(thread.isAlive());       // falsethread.start();// 线程启动后尚未结束时返回 trueSystem.out.println(thread.isAlive());       // true
}

11. public final void join():等待线程死亡，等同于join(0)
12. public final synchronized void join(long millis):等待这个线程死亡的时间最多为millis毫秒。 0的超时意味着永远等待
    • join可以理解为当我们调用某个线程的这个方法时，这个方法会挂起调用线程，直到被调用线程结束执行，调用线程才会继续执行。(让父线程等待子线程结束之后才能继续运行)

 public static void main(String[] args){Thread th= new Thread(runnable);th.start();try {// 在main执行， main线程等待 th 执行完毕后再执行th.join();// main线程等待 th 执行 1s 后再执行
//            th.join(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println("main end");}

13. public void interrupt():中断这个线程，线程的中断状态标记为 true

14. public static boolean interrupted():测试当前线程是否中断。 该方法可以清除线程的中断状态(设置中断状态为False) 。 换句话说，如果这个方法被连续调用两次，那么第二个调用将返回false（除非当前线程再次中断，在第一个调用已经清除其中断状态之后，在第二个调用之前已经检查过）。

15. public boolean isInterrupted():测试这个线程是否被中断。 线程的中断状态不受此方法的影响。不清除中断状态。

public static void main(String[] args) {Runnable runnable = new Runnable() {@Overridepublic void run() {Thread thread = Thread.currentThread();for (int i = 0; i < 10; i++) {if (i % 3 == 0) {// 中断线程， 标记线程中断状态thread.interrupt();}// 测试当前线程是否中断System.out.println(Thread.interrupted());//true false false true false false true false false true}int count = 0;while (!thread.isInterrupted()) {if (count == 5) {// 当count == 5 时，线程就会被中断thread.interrupt(); // 我想停}System.out.println("执行" + count ++);    // 执行0 执行1 执行2 执行3 执行4 执行5}}};Thread thread = new Thread(runnable);thread.start();
}

16. • public static native void yield():导致当前执行线程处于让步状态。如果有其他可运行线程具有至少与此线程同样高的优先级，那么这些线程接下来会被调度。并不一定会让出去。

17. public State getState():返回此线程的状态,返回值是Thread的一个内部类，枚举类State。线程状态可以是：

    • NEW: 尚未启动的线程处于此状态。
    • RUNNABLE: 在Java虚拟机中执行的线程(可以运行的线程)处于此状态。
    • BLOCKED: 被阻塞等待监视器锁定的线程处于此状态。
    • WAITING: 正在等待另一个线程执行特定动作的线程处于此状态。
    • TIMED_WAITING: 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。 (sleep(1000),join(1000))
    • TERMINATED: 已退出的线程处于此状态。