多线程与高并发学习笔记2

二、线程的使用

创建线程的三种方式：

方式1: 继承 Thread

import java.util.concurrent.TimeUnit;

/**
 * 通过继承方式创建线程
 *
 * @author 赵帅
 * @date 2021/1/1
 */
public class CreateMyThreadByExtendThread extends Thread {

    @Override
    public void run() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("通过继承方式实现自定义线程，当前线程为：" + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        // 当前线程为主线程 main
        System.out.println("Thread.currentThread().getName() = " + Thread.currentThread().getName());

        // 创建一个新的线程并开启线程，打印新的线程名
        CreateMyThreadByExtendThread thread = new CreateMyThreadByExtendThread();
        thread.start();
    }
}

方式2: 实现Runnable接口

import java.util.concurrent.TimeUnit;

/**
 * 通过实现Runnable接口方式
 *
 * @author 赵帅
 * @date 2021/1/1
 */
public class CreateMyThreadByImplRunnable implements Runnable {

    @Override
    public void run() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("通过实现Runnable接口方式实现自定义线程，当前线程为：" + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        // 当前线程为主线程 main
        System.out.println("Thread.currentThread().getName() = " + Thread.currentThread().getName());

        // 创建一个新的线程并开启线程，打印新的线程名
        Thread thread = new Thread(new CreateMyThreadByImplRunnable());
        thread.start();
    }
}

方式3: Callable+Feature

import java.util.concurrent.*;

/**
 * 通过实现Callable接口方式
 *
 * @author 赵帅
 * @date 2021/1/1
 */
public class CreateMyThreadByImplCallable implements Callable<String> {

    @Override
    public String call() throws Exception {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("通过实现Callable接口方式实现自定义线程，当前线程为：" + Thread.currentThread().getName());
        return "hello";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 当前线程为主线程 main
        System.out.println("Thread.currentThread().getName() = " + Thread.currentThread().getName());

        // callable接口实现的任务和Future接口或线程池一起使用
        CreateMyThreadByImplCallable callable = new CreateMyThreadByImplCallable();

        // 和Feature一起使用，Future表示未来，也就是说我执行这个任务，未来我去取任务执行的结果
        FutureTask<String> task = new FutureTask<>(callable);
        new Thread(task).start();
        System.out.println("main线程继续运行");

        // 等其他线程执行完了，再来拿task的结果，
        System.out.println("task.get() = " + task.get());


        // 使用线程池方式调用callable
        Future<String> submit = Executors.newSingleThreadExecutor().submit(callable);
        System.out.println("submit.get() = " + submit.get());
    }
}

三种方式的区别

通过上面三种创建线程的方式，我们对线程的使用有了基本的了解，下面我们来分析这三种方式有什么区别：

继承Thread：通过继承方式创建线程，因为java单继承的特性，使用的限制就非常多了，使用不方便。
实现Runnable：因为单继承的限制，所以出现了Runnable，接口可以多实现，因此大大提高了程序的灵活性。但是无论是继承Thread还是实现Runnable接口，线程执行的方法都是 void 返回值。
实现Callable： Callable接口就是为了解决线程没有返回值的问题，Callable接口有一个泛型类型，这个泛型就代表返回值的类型，使用Callable接口就可以开启一个线程取执行, Callable一般和Future接口同时使用，返回值为Future类型，可以通过Future接口的get方法拿执行结果。get()方法是一个阻塞的方法。

相同点：都是通过Thread类的start()方法来开启线程。

线程的方法

start(): 开启线程，使线程从新建进入就绪状态
sleep(): 睡眠，使当前线程休息, 需要指定睡眠时间，当执行sleep方法后进入阻塞状态，

Join()：加入线程，会将调用的线程加入当前线程。等待加入的线程执行完成后才会继续执行当前线程。

/**
 * 线程方法示例
 * @author 赵帅
 * @date 2021/1/1
 */
public class ThreadMethodDemo {
    public static void main(String[] args) throws InterruptedException {
        // 打印当前线程 main线程的线程名 main
        System.out.println("当前主线程线程名 = " + Thread.currentThread().getName());

        // 创建一个新的线程
        Thread thread = new Thread(() -> {

            // 线程进入睡眠状态
            try {
                Thread.sleep(1000L);
                System.out.println("当前线程名：" + Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // 开启线程 thread
        thread.start();

//        thread.join();
        System.out.println("主线程执行完毕");
    }
}

打开和关闭注释thread.join()可以发现输出结果是不一样的，使用join后会等待thread执行结束后再继续执行main方法。

wait(): 当前线程进入等待状态，让出CPU给其他线程，自己进入等待队列，等待被唤醒。
notify(): 唤醒等待队列中的一个线程，唤醒后会重新进入就绪状态，准备抢夺CPU。
notifyAll(): 唤醒等待队列中的所有线程，抢夺CPU。

yield(): 让出CPU。当前线程让出CPU给其他的线程执行，但是自己也会进入就绪状态参与CPU的抢夺，因此调用yield方法后，仍然可能继续获得CPU。

import java.util.concurrent.TimeUnit;

/**
 * 线程方法示例
 * @author 赵帅
 * @date 2021/1/1
 */
public class ThreadMethodDemo {
    public static void main(String[] args) throws InterruptedException {
        // 打印当前线程 main线程的线程名 main
        System.out.println("当前主线程线程名 = " + Thread.currentThread().getName());

        Object obj = new Object();

        // 创建一个新的线程
        Thread thread = new Thread(() -> {

            // 线程进入睡眠状态
            try {
                synchronized (obj) {
                    obj.wait();
                    System.out.println("当前线程名：" + Thread.currentThread().getName());
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // 开启线程 thread
        thread.start();

        System.out.println("主线程执行完毕");
        // 等待thread进入等待状态释放锁，否则会产生死锁
        TimeUnit.SECONDS.sleep(6);
        synchronized (obj) {
            obj.notify();
        }
    }
}

注意：wait和notify只能在synchronized同步代码块中调用，否则会抛异常。

Interrupt(): 中断线程，调用此方法后，会将线程的中断标志设置为true。

线程的状态

一个完整的线程的生命周期应该包含以下几个方面：

新建(New)：创建了一个线程，但是还没有调用start方法
就绪(Runnable)：调用了start()方法，线程准备获取CPU运行
运行(Running)：线程获取CPU成功，正在运行
等待(Waiting)：等待状态，和TimeWaiting一样都是等待状态，不同的是Waiting是没有时间限制的等，而TimeWaiting会进入一个有时间限制的等。例如调用wait()方法后就会进入一个无限制的等，等待调用notify唤醒，而调用sleep( time)就会进入一个有时间限制的等。等待结束后(被唤醒或sleep时间到期)后就会重新进入就绪队列，等待获取CPU继续向下执行。
阻塞(Blocked)：多个线程再等待临界区资源时，进入阻塞状态。
销毁(Teminated): 线程执行完毕，进入销毁状态，这个状态是不可逆的，是最终状态，当进入这个状态时，就代表线程执行结束了。

以一张图来理解这几个状态：

简单介绍一个线程的生命周期：

当我们使用 new Thread()创建一个线程时，那么这个线程就处于创建状态；当我们调用start()方法后，此时线程就处于就绪状态(进入就绪状态后就不可能再进入创建状态了)，但是调用start()方法后并不是说立马就会被CPU执行，而是会参与CPU的抢夺，当这个线程拿到CPU后，就会被执行。那么拿到CPU后就进入了运行状态。当调用了sleep或wait方法后，线程就进入了等待状态，当等待状态被唤醒后，就会重新进入就绪队列等待获取CPU，当访问同步资源时或其他阻塞式操作时就会进入阻塞状态，阻塞状态结束重新进入就绪状态获取CPU。当线程运行完成后进入Teminate状态后，就代表线程执行结束了。

sleep操作不释放锁，wait操作释放锁。

多线程与高并发学习笔记2

二、 线程的使用

三种方式的区别

线程的方法

线程的状态

二、线程的使用