Java学习笔记 --- 多线程

一、线程相关概念 

程序

        程序是为完成特定任务，用某种语言编写的一组指令的集合。简单的说就是我们写的代码

进程

        1、进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的内存空间

        2、进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：是它自身的产生、存在和消亡的过程

什么是线程

        1、线程是由进程创建的，是进程的一个实体

        2、一个进程可以拥有多个线程

其它相关概念

        1、单线程：同一个时刻，只允许执行一个线程

        2、多线程：同一个时刻，可以执行多个线程。比如：一个qq进程可以同时打开多个聊天窗口，一个迅雷进程可以同时下载多个文件

        3、并发：同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说，单核cpu实现的多任务就是并发

        4、并行：同一个时刻，多个任务同时执行。多核cpu可以实现并行

二、线程基本使用

        在java中线程来使用有两种方法

继承Thread类，重写run方法

import java.util.ArrayList;
 
/**
 * 演示通过继承 Thread 类创建线程
 */
public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        //创建Cat对象，可以当作线程使用
        Cat cat = new Cat();
 
        /* start()方法源码解读
           1. 调用start0();
           public synchronized void start() {
               start0();
           }
           2. start0() 是本地方法，是JVM调用，底层是c/c++实现
              真正实现多线程效果的是 start0() 方法，而不是run
           private native void start0();
         */
        cat.start();//启动线程 -> 最终会执行cat的run方法
        //cat.run();//run方法就是一个普通的方法，没有真正启动一个线程，把run方法执行完毕，才会向下执行
 
        //当 main 线程启动了一个子线程，主线程不会阻塞，会继续执行
        //这时主线程和子线程是交替执行
        System.out.println("主线程继续执行" + Thread.currentThread().getName());
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程 i=" + i);
            //让主线程休眠一秒
            Thread.sleep(1000);
        }
    }
}
 
//当一个类继承了Thread 该类就可以当做线程使用
//重写run方法，写上自己的业务代码
//run方法 是 Thread 类实现了 Runnable 接口的run方法
/*
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
 */
class Cat extends Thread {
    int times = 0;
    @Override
    public void run() {//重写run方法，写上自己的逻辑
        while (true) {
            System.out.println("喵喵喵~~~" + ++times + " 线程名=" + Thread.currentThread().getName());
 
            //让线程休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (times == 8) {//当times到8次时就退出循环，线程也就退出
                break;
            }
        }
    }
}

实现Runnable接口，重写run方法

        1、Java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时在用继承Thread类方法来创建线程显然已经不可能了  

        2、Java设计者们提供了另一个方式创建线程，就是通过实现Runnable接口来创建线程

 
import sun.rmi.runtime.RuntimeUtil;
 
/**
 * 通过实现Runnable接口，来开发线程
 */
public class Thread02 {
    public static void main(String[] args) throws InterruptedException {
        Dog dog = new Dog();
        //dog对象不能直接调用start()方法
        //创建了Thread对象，把dog对象(实现了Runnable)，放入Thread
        Thread thread = new Thread(dog);
        thread.start();
 
        Tiger tiger = new Tiger();//实现了Runnable
        ThreadProxy threadProxy = new ThreadProxy(tiger);
        threadProxy.start();
    }
}
 
class Animal {}
class Tiger extends Animal implements Runnable {
 
    @Override
    public void run() {
        System.out.println("老虎叫！！！");
    }
}
 
//线程代理类 模拟了一个极简的Thread
class ThreadProxy implements Runnable {
    private Runnable target = null;//属性 类型是Runnable
 
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
 
    public ThreadProxy(