多线程

多线程概述

多线程就是计算机用时运行多个任务
但实质上，同一个时间点，只会运行一个任务，只是计算机在不同任务之间来回切换而已。

并发和并行

并行：在同一时间，多个任务分别在多个CPU上进行。

并发：在同一时间，多个任务在同一个CPU交替进行。

线程和进程

进程

独立性：进程是一个独立运行的应用程序。
动态性：进程就是一个程序运行的过程，程序开始运行，进程创建，运行接收，进程消亡。
并发性：任何进程可以和其他进程并发执行。

线程不能单独存在，线程是进程的一部分，一个进程可以有多可线程，但必须至少有一个线程。

多线程实现

实现多线程方式一：继承Thread类，Thread类就是线程类，要实现多线程必须创建Thread类对象。

自定义类通过继承Thread类，再重写run() 方法

public class ThreadDemo extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"的第"+i+"次");
        }
    }
}

在测试类中创建自定义类对象

public class TestDemo {
    public static void main(String[] args) {
        ThreadDemo t1 = new ThreadDemo();
        //为线程设置名字
        t1.setName("线程1");
        //start() 方法告诉JVM程序会启用多线程，并自动调用run() 方法
        //直接执行run() 方法，那么就是执行一个普通的单线程方法
        t1.start();

        ThreadDemo t2 = new ThreadDemo();
        t2.setName("线程2");
        t2.start();
    }
}

实现多线程方式二：实现Runnable接口

public class RunnableDemo implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //让线程停止指定毫秒数
            //父类Thread没有抛出异常，所以子类只能自己捕获异常
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            //调用Thread的静态方法currentThread()，可以直接获取当前的进程
            System.out.println("这是线程"+Thread.currentThread().getName()+i);
        }
    }
}

测试类

public class TestDemo2 {
    public static void main(String[] args) {
        RunnableDemo ra = new RunnableDemo();

        //调用Thread() 的带参方法，传入一个Runnable的实现类对象
        Thread thread = new Thread(ra);
        thread.setName("西安");
        //为该线程设置优先级1(min)-10(max),优先级越高，抢占CPU的几率就越大，但不会达到100%
        thread.setPriority(10);
        //获取优先级
        System.out.println(thread.getPriority());
        thread.start();
        
        Thread thread2 = new Thread(ra);
        thread2.setPriority(1);
        //获取优先级
        System.out.println(thread2.getPriority());
        thread2.setName("杭州");
        thread2.start();
    }
}

实现Callable接口

public class CallableDemo implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("和班主任请假第"+i+"次");
        }
        return "同意";
    }
}

测试类

public class TestDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CallableDemo cd = new CallableDemo();
        FutureTask<String> ft = new FutureTask<>(cd);
        Thread thread = new Thread(ft);
        thread.start();
        FutureTask<String> ft2 = new FutureTask<>(cd);
        Thread thread2 = new Thread(ft2);
        thread2.start();
        //注意如果在start方法之前 调用get() 方法，意味着在开启线程之前获取返回值，但是此时线程尚未开启，这就照成死锁
        String o = ft.get();
        String o2 = ft2.get();
        System.out.println(o);
        System.out.println(o2);
    }
}

总结如下：

方式一：通过自定义类继承Thread的方式。

优点：子类可以直接调用父类的方法，缺点，对子类限制比较大，不能再继承其他类

方式二：通过自定义类实现Runnable接口的方式。

优点：通过实现接口的方式，子类还可以继承其他类，拓展性更强

缺点：不能直接启用多线程，需要先创建Runnable实现类对象，再使用Thread的带参构造传入Runnable实现类对象，再通过Thread对象启用多线程

方式三：通过自定义类实现Callable接口的方式

优点:通过实现接口的方式，子类还可以继承其他类,执行线程后还可以返回值

缺点：不能直接启用多线程，需要先需要先创建Callable实现类对象，再使用FutureTask的带参构造传入Runnable实现类对象，再使用Thread的带参构造传入FutureTask类对象，再通过Thread对象启用多线程

守护线程

守护线程会因为普通线程结束而结束，无论守护线程是否执行完毕

代码如下：

public class DaemonDemo {
    public static void main(String[] args) {
        Test1 t1 = new Test1();
        t1.setName("主人");
        t1.setPriority(1);
        t1.start();
        
        Test2 t2 = new Test2();
        t2.setDaemon(true);
        t2.setName("保镖");
        t2.setPriority(10);
        t2.start();
    }
}
/**
 * 主人线程
 */
public class Test1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+"..."+i);
        }
    }
}
/**
 * 保镖线程
 */
public class Test2 extends Thread{
    @Override
    public void run() {
        try {
            Thread.sleep(3);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"==="+i);
        }
    }
}