六、03【Java 多线程】之Java线程

Java 创建线程的方式

Java创建线程有四种方式：

• 继承 Thread 类
• 实现 Runnable 接口
• 实现 Callable 接口
• 使用 Executors 工具类创建线程池

1）继承 Thread 类

创建一个类继承 Thread，重新run()方法。run() 方法就是线程要执行的业务逻辑方法。

将该类进行实例化，调用 star() 方法来启动线程。

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " run()方法正在执行...");
    }
}

public class ThreadTest {

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        System.out.println(Thread.currentThread().getName() + " main()方法执行结束");
    }
}

执行结果：
main main()方法执行结束
Thread-0 run()方法正在执行...

2）实现 Runnable 接口

创建一个类实现 Runnable 接口，并重写run()方法。

将该类的实例作为 target 创建Thead对象，该Thread对象才是真正的线程对象。

调用 star() 方法来启动线程。

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " run()方法正在执行...");
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
        System.out.println(Thread.currentThread().getName() + " main()方法执行结束");
    }
}

执行结果：
main main()方法执行结束
Thread-0 run()方法正在执行...

3）实现 Callable 接口

创建实现Callable接口的类MyCallable，以myCallable为参数创建FutureTask对象，

将FutureTask作为参数创建Thread对象，调用线程对象的 start() 方法。

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() {
        System.out.println(Thread.currentThread().getName() + " call()方法执行中...");
        return 1;
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        FutureTask<Integer> futureTask = new FutureTask<>(new MyCallable());
        Thread thread = new Thread(futureTask);
        thread.start();
        try {
            Thread.sleep(1000);
            System.out.println("返回结果 " + futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " main()方法执行完成");
    }
}

执行结果：
Thread-0 call()方法执行中...
返回结果 1
main main()方法执行完成

4）使用 Executors 工具类创建线程池

Executors提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService接口。

主要有newFixedThreadPool，newCachedThreadPool，newSingleThreadExecutor，newScheduledThreadPool 四种

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " run()方法执行中...");
    }
}

public static void main(String[] args) {
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    MyRunnable myRunnable = new MyRunnable();
    for (int i = 0; i < 5; i++) {
        executorService.execute(myRunnable);
    }
    System.out.println("线程任务开始执行...");
    executorService.shutdown();
}

执行结果：
线程任务开始执行...
pool-1-thread-1 run()方法正在执行...
pool-1-thread-1 run()方法正在执行...
pool-1-thread-1 run()方法正在执行...
pool-1-thread-1 run()方法正在执行...
pool-1-thread-1 run()方法正在执行...


public static void main(String[] args) {
    ExecutorService executorService = Executors.newFixedThreadPool(5);
    MyRunnable myRunnable = new MyRunnable();
    for (int i = 0; i < 5; i++) {
        executorService.execute(myRunnable);
    }
    System.out.println("线程任务开始执行...");
    executorService.shutdown();
}

执行结果：
线程任务开始执行...
pool-1-thread-1 run()方法正在执行...
pool-1-thread-3 run()方法正在执行...
pool-1-thread-2 run()方法正在执行...
pool-1-thread-4 run()方法正在执行...
pool-1-thread-5 run()方法正在执行...

上面实现多线程的几种方式各有优点：使用继承的优点就是方便传参，可以在子类添加成员变量，通过set方法或构造函数进行设置参数，如果使用Runable的方式，则只能使用主线程里面被声明为final的变量。使用继承的缺点就是，如果继承了Thread类，那么就不能继承其他类了，因为Java里面不支持多继承，而Runable则不会。这两种方式都没办法拿到返回结果，但是实现Callable使用FutureTask则可以拿到返回结果。

Thread 类

Thread 是程序中执行的线程。 Java虚拟机允许应用程序具有多个并发运行的执行线程。

每个线程都有优先级。优先级较高的线程优先于优先级较低的线程执行。每个线程也可以标记为守护进程，也可以不标记为守护进程。当在某个线程中运行的代码创建新的线程对象时，新线程的优先级最初设置为与创建线程的优先级相等，并且仅当创建线程是守护进程时，该线程才是守护进程线程。

当Java虚拟机启动时，通常只有一个非守护进程线程（它通常调用某个指定类的main方法）。Java虚拟机将继续执行线程，直到发生以下任一情况：

1）类运行时的exit方法已被调用，并且安全管理器已允许执行exit操作。

2）所有不是守护进程线程的线程都已死亡，要么是通过调用run方法返回，要么是通过抛出传播到run方法之外的异常。

每个线程都有一个名称用于标识。多个线程可以有相同的名称。如果在创建线程时没有指定名称，则会为其生成一个新名称。

除非另有说明，若将null参数传递给此类中的构造函数或方法将导致引发NullPointerException。

Java 线程依赖于此类。

属性&构造函数

// 线程是否为守护线程。
private boolean daemon = false;
// jvm 状态
private boolean stillborn = false;
// 线程将会运行什么
private Runnable target;
// 这个线程组
private ThreadGroup group;
// 线程的ID
private long tid;
// 线程状态，初始化以表示线程“尚未启动”
private volatile int threadStatus = 0;
// ....
// 线程可以拥有的最小优先级。
public final static int MIN_PRIORITY = 1;
// 分配给线程的默认优先级。
public final static int NORM_PRIORITY = 5;
// 线程可以拥有的最大优先级。
public final static int MAX_PRIORITY = 10;

// 构造函数
// 创建一个新的线程对象。此构造函数与Thread(ThreadGroup,Runnable,String)具有相同的效果。全部使用默认。
public Thread() {}
// 创建一个新的线程对象。指定线程运行目标，与Thread(ThreadGroup,Runnable,String)具有相同的效果。默认线程名：“Thread-”+n，n为整数。
public Thread(Runnable target){}
// 创建一个新的线程对象。指定线程组和线程运行目标，与Thread(ThreadGroup,Runnable,String)具有相同的效果。使用默认线程名。
public Thread(ThreadGroup group,Runnable target){}
// 创建一个新的线程对象。并指定这个线程的名称，与Thread(ThreadGroup,Runnable,String)相同的效果。
public Thread(String name){}
// 创建一个新的线程对象。指定这个线程的线程组和线程名称，这个构造函数具有与Thread(ThreadGroup,Runnable,String)相同的效果。
public Thread(ThreadGroup group,String name){}
// 创建一个新的线程对象。指定线程运行目标和线程名。
public Thread(Runnable target,String name){}
// 创建一个新的线程对象。指定线程组、线程运行目标和线程名。如果有安全管理器，则使用ThreadGroup作为参数调用它的checkAccess方法。
// 此外，当重写getContextClassLoader或setContextClassLoader方法的子类的构造函数直接或间接调用其checkPermission方法时，
// 会使用RuntimePermission("enableContextClassLoaderOverride")权限调用其checkPermission方法。
// 新创建线程的优先级与创建它的线程(即当前运行的线程)的优先级相等。setPriority方法可以用来将优先级更改为一个新值。
// 当仅创建线程的线程当前被标记为守护线程时，新创建的线程最初被标记为守护线程。setDaemon方法可