java多线程实现与总结

1.进程与线程

• 说起进程，就不得不说程序。程序是指令和数据的有序集合，它本身只是一个静态的概念。没有运行的含义

• 而进程是执行程序的一次执行过程，它是一个动态的概念。进程是系统分配资源的单位

• 通常一个进程包含若干个线程，至少包含一条线程，否则没有存在的意义。线程是CPU执行和调度的单位

注意：
很多的多线程是模拟出来的，真正的多线程是指有多个CPU同时跑多个线程。当只有一个CPU时，在同一时间，CPU只能执行一个代码，也就是一条线程，只是线程之间的切换比较快，人一般难以察觉，会误以为是同时进行

2.线程创建的方式

1.继承Thread类

（1）继承Thread类
（2）重写 run() 方法
（3）调用 start() 方法启动线程

// 不建议使用，避免oop单继承局限性
// 线程开启不一定执行，由CPU调度执行
// 创建线程方法一：继承Thread类，重写run()方法，调用start()开启线程
public class TestThread1 extends Thread{  // 1、继承Thread类
    @Override
    public void run() {     // 2、重写run()方法
        //run()方法线程体
        for (int i = 0; i < 2000; i++) {
            System.out.println("我在学习多线程" + i);
        }
    }

    public static void main(String[] args) {
        // main方法，主线程
        // 创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        // 3、调用start()开启线程
        testThread1.start();

        for (int i = 0; i < 2000; i++) {
            System.out.println("我在看书" + i);
        }
    }
}

执行结果是我在看书和我在学习多线程交替执行的。至于执行顺序是什么是由CPU调度执行的

2.实现Runnable接口（推荐）

（1）实现Runnable接口
（2）重写 run() 方法
（3）创建一个线程对象，将线程对象传入Thread实例（对象）中
（4）Thread对象调用start()方法启动线程

// 推荐使用，避免单继承局限性，灵活方便，方便同一个对象被多个线程调用
// 创建线程方法二：实现Runnable接口，重写run()方法，执行线程需要丢入Runnable接口实现类，调用start()方法
public class TestThread2 implements Runnable{ // 1、实现Runnable接口
    @Override
    public void run() {  // 2、重写run()方法
        //run()方法线程体
        for (int i = 0; i < 2000; i++) {
            System.out.println("我在学习多线程"+i);
        }
    }
    public static void main(String[] args) {
        // main方法，主线程
        // 3.1、创建一个线程对象
        TestThread2 t2 = new TestThread2();
        // 3.2、丢入Runnable接口实现类
        Thread thread = new Thread(t2);

        // 4、调用start()开启线程
        thread.start();

        for (int i = 0; i < 2000; i++) {
            System.out.println("我在看书"+i);
        }
    }
}

3.实现Callable接口

（1）实现Callable接口，需要返回值
（2）重写call() 方法，需要抛出异常
（3）创建目标对象
（4）将目标对象传入FutureTask构造器生成FutureTask实例化对象
（5）将FutureTask实例对象传入Thread，生成Thread对象
（6）Thread对象调用start()开启线程

注意：使用此方法创建线程可以通过get()方法可以获取返回值,需抛出异常

/**
 * 创建线程方法三：实现Callable接口，重写call()方法，
 * 创建目标对象传入FutureTask构造器生成FutureTask对象
 * 将FutureTask对象传入Thread类生成Thread对象，调用start()方法开启线程
 * 
 * 注意：使用此方法创建线程可以通过get()方法可以获取返回值,需抛出异常
 */
public class TestThread3 implements Callable { // 1、实现Callable接口
    @Override
    public String call() throws Exception { // 2、重写call()方法，需抛出异常，有返回值
        for (int i = 0; i < 2000; i++) {
            System.out.println("我在学习多线程" + i);
        }
        return "线程已执行";
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // main方法，主线程
        // 3、创建一个目标对象
        TestThread3 t3 = new TestThread3();

        // 4、将目标对象传入FutureTask构造器生成FutureTask实例化对象
        FutureTask<String> futureTask = new FutureTask<String>(t3);

        // 5、将FutureTask实例对象传入Thread，生成Thread对象
        Thread thread = new Thread(futureTask);

        // 6、调用start()开启线程
        thread.start();

        // 通过get()方法可以获取返回值,需抛出异常
        String str = futureTask.get();
        System.out.println("str = " + str);
    }
}

4.Lambda表达式

（1）在Thread构造器中传入Lambda表达式生成Thread对象
（2）调用start()方法启动线程

// 线程创建方法四：Lambda表达式,在Thread构造器中传入Lambda表达式生成Thread对象，调用start()方法启动线程
public class TestThread4 {
    public static void main(String[] args) {
        // 1、传入Lambda表达式
        Thread thread = new Thread(()->{
            for (int i = 0; i < 2000; i++) {
                System.out.println("我在学习多线程" + i);
            }
        });
        // 2、调用start()方法启动线程
        thread.start();
        for (int i = 0; i < 2000; i++) {
            System.out.println("我在看书" + i);
        }
    }
}

实质上，Runnable接口就是一个函数式接口，所以这其实属于实现Runnable接口实现线程的方式，只是将方法体直接写在Thread构造参数里

3.线程的状态

来自狂神视频的图片

1、新建状态（new）：当使用new Thread()新建一条线程时，此时线程并未启动，只是出于新建状态

2、就绪状态（Runnable）：当使用了start()方法时，此时线程进入就绪状态，但并不会立即执行run()方法里的代码，而是等待CPU的调度

3、运行状态（Running）：当线程获得CPU分配的资源时开始运行，此时才会执行run()方法里的代码

4、阻塞状态（Blocked）：当线程在运行过程中可能由于各种原因进入阻塞状态，例如调用sleep()，wait()方法等，此时线程会进入阻塞状态，暂时让出CPU资源，其它就绪状态的线程就可以抢夺资源运行线程，进入阻塞状态的资源要想运行，也要先进入就绪状态，等待CPU调度才能再次运行

5、死亡状态（Dead）：线程进入死亡状态有两种方式，一个是执行完run()里面的代码，第二个是遇到异常提前结束。要想知道线程是否是死亡状态，可以使用isAlive()方法判断，如果是就绪、运行或者阻塞状态会返回true，处于new和死亡状态会返回false

4.线程的一些方法

1、sleep()

• sleep(时间)，指定当前线程阻塞的毫秒数，例如sleep(3000)表示当前线程阻塞3000毫秒；

• sleep存在异常状态InterruptedException，需抛出异常；

• sleep时间到达后线程进入就绪状态；

• sleep可以模拟网网络延时，倒计时等；

• 再有锁的情况下，sleep不会释放锁；

小问题：sleep(0)有什么用？
sleep(0)表示睡眠0毫秒，乍看一下没有什么用，但是线程确实是被挂起了一瞬间，此时，线程会让出自己的CPU资源，进入阻塞状态，让其他线程去抢夺，也就是有机会先执行，其实它也就是起到一个礼让的作用

2、yield()

• 礼让线程，让当前正在执行的线程暂停，但不阻塞；

• 将线程运行状态转为就绪状态；

• 让CPU重新调度，礼让不一定成功，看CPU如何调度；

/**
 * 测试你让线程
 * 礼让不一定成功,看CPU如何调度
 */
public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }


}
class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始运行！");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程结束运行！");
    }
}

3、join()

• join合并线程，等到这个线程执行完后其他线程才可以执行，其他线程阻塞；

• 其实就是强制插队

/**
 * 测试join
 */
public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("vip线程来了！"+i);
        }

    }
    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        for (int i = 0; i < 1000; i++) {
            if(i==200){
                thread.join();  // 插队
            }
            System.out.println("main线程"+i);
        }
    }
}