Java线程

Java线程一共6个状态。

package chapter09;public class Java01_Thread {public static void main(String[] args) {// TODO 线程// Thread是线程类// currentThread 方法用于获取当前正在运行的线程// getName 方法获取线程的名字// main方法运行在main线程中
//        System.out.println(Thread.currentThread().getName());
//
//        // todo 创建线程
        Thread t = new Thread();
//        MyThread t = new MyThread();
//        // todo 启动线程
//        t.start();
//
//        System.out.println(Thread.currentThread().getName());// todo 构建线程对象时，可以只把逻辑传递给这个对象//      传递逻辑时，需要遵循规则： () -> { 逻辑 }//      ()->{} 是一个 lambda 表达式。它实现了 Runnable 接口的 run 方法//      Runnable 接口是一个函数式接口（只有一个抽象方法的接口），因此可以使用 lambda 表达式来简化代码。//      Lambda 表达式 简化了函数式接口的实现，使代码更简洁。//      等价写法 可以使用匿名内部类来实现Thread thread1 = new Thread(() -> {System.out.println("线程执行1");});// 等价于下面的写法// 构建线程对象时，可以传递实现了Runnable接口的对象，一般使用匿名类// Thread thread1 = new Thread(new Runnable() {//    @Override//    public void run() {//        System.out.println("线程执行1");//    }//});thread1.start();}
}// TODO 声明自定义线程类
class MyThread extends Thread {@Overridepublic void run() {System.out.println("MyThread :" + Thread.currentThread().getName());}
}

package chapter09;import java.io.IOException;public class Java02_多线程 {public static void main(String[] args) throws InterruptedException {// TODO 多线程 - 执行方式 (串行，并发)// 并发执行：多个线程是独立的，谁抢到CPU执行权，谁就能执行
//        int i = 0;
//        while (i++ < 100) {
//            MyThread1 t1 = new MyThread1();
//            MyThread2 t2 = new MyThread2();
//            t1.start();
//            t2.start();
//            System.out.println("xxxxxxxxxxxx\n");
//        }// 串行执行：多个线程连接成串，然后按照顺序执行int i = 0;while (i++ < 100) {MyThread1 t1 = new MyThread1();MyThread2 t2 = new MyThread2();t1.start();t2.start();// 将线程连接成串t1.join();t2.join();System.out.println("xxxxxxxxxxxx\n");}}
}class MyThread1 extends Thread {@Overridepublic void run() {System.out.println("MyThread1 :" + Thread.currentThread().getName());}
}class MyThread2 extends Thread {@Overridepublic void run() {System.out.println("MyThread2 :" + Thread.currentThread().getName());try {Thread.sleep(1000); // 休眠1秒钟} catch (InterruptedException e) {throw new RuntimeException(e);}}
}

四种常见的线程池

package chapter09;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class Java05_Thread_Pool {public static void main(String[] args) {// TODO 线程 - 线程池// 所谓线程池，其实就是线程对象的容器// 可以根据需要，在启动时，创建一个或多个线程对象// Java中有4种比较常见的线程池// 1. 创建固定数量的线程对象//    ExecutorService是线程服务对象ExecutorService executorService = Executors.newFixedThreadPool(3);// 2. 根据需求动态创建线程, 创建的线程可以重复使用，只是当目前线程不够了他会动态增加线程executorService = Executors.newCachedThreadPool();// 3. 单一线程executorService = Executors.newSingleThreadExecutor();// 4. 定时调度线程, 线程有3个，但是线程在什么时候执行我们可以去定义他executorService = Executors.newScheduledThreadPool(3);for (int i = 0; i < 5; i++) {executorService.submit(new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName());}});}}
}

---

在 Java 中，创建并启动一个新的线程通常有两种主要的方式：继承 Thread 类和实现 Runnable 接口。

1. 通过继承 Thread 类来创建一个新的线程类，并重写 Thread 类的 run() 方法。

class MyThread extends Thread {@Overridepublic void run() {System.out.println("Thread is running");}public static void main(String[] args) {MyThread t = new MyThread();t.start();  //启动线程}
}

2. 通过实现 Runnable 接口并实现其 run() 方法，然后将 Runnable 实例传递给 Thread 对象。

class MyRunnable implements Runnable {@Overridepublic void run() {System.out.println("Thread is running");}public static void main(String[] args) {MyRunnable r = new MyRunnable();Thread t = new Thread(r);t.start();}
}

特性	继承 Thread 类	实现 Runnable 接口
继承	不支持多继承，限制较大	支持多继承，更灵活
代码解耦	线程逻辑和线程控制耦合	线程逻辑和线程控制分离
复用性	不易复用	更易复用
共享资源	需要额外处理	自然适应共享资源

ps：若两个同时使用呢？

class BothRunnableThread {public static void main(String[] args) {// 创建一个匿名内部类实现 Runnable 接口的 run 方法new Thread(new Runnable() {@Overridepublic void run() {// 这个 run 方法来自于 Runnable 接口System.out.println("I am runnable");}}) {// 创建一个匿名内部类继承 Thread 类并重写其 run 方法@Overridepublic void run() {// 这个 run 方法来自于 Thread 类System.out.println("I am thread");}}.start();  // 启动线程}
}

结果是：

原因：
创建了一个实现了 Runnable 接口的匿名内部类的对象，然后这个Runnable类的匿名内部类的对象被传给Thread的target。

但是Thread的下面三行run方法被重写了，也就不用管Runnable类的target了，虽然Runnable类的target的run方法被重写了，所以没机会执行Runnable类的target的run方法了。

---