认识线程（Thread）

一、概念

1、进程是系统分配资源的最小单位

2、线程是系统调度的最小单位。

一个进程内的线程之间是可以共享资源的。每个进程至少有一个线程存在，即主线程

二、观察进程和线程

1、工具

（1）可以通过JDK提供的Java监控工具来观察（jconsole.exe和jvisualvm.exe）

（2）这两个工具的位置在JDK的bin目录下

（3）打开方式：

在文件夹中双击打开
在cmd命令行中输入相应指令打开

2、几段代码

（1）Java进程的运行实质上是调用java 包名.类名，来启动java程序 -->java进程运行

（2）java命令代码执行：启动系统main方法，一般是C语言的main函数入口——系统级别的main线程（每个进程至少有一个线程存在，即主线程）

（1）观察让main线程阻塞

public static void main(String[] args) throws InterruptedException {
        Thread.sleep(999999999999999L);
    }

（2）观察子线程阻塞

//main线程已经结束，子线程还处于阻塞状态
public static void main(String[] args) throws InterruptedException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(999999999999999L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"第一个线程").start();
    }

（3）观察main和子线程同时阻塞

public static void main(String[] args) throws InterruptedException {
			new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(999999999999999L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"第一个线程").start();
        Thread.sleep(999999999999999L);
    }

（4）观察main线程运行run方法

public static void main(String[] args) throws InterruptedException {  
       Thread t = new Thread(new Runnable() { //创建一个线程
            @Override
            public void run() {
                try {
                    Thread.sleep(999999999999999L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }//运行态时，执行的代码
        },"第一个线程");//启动一个线程，申请系统调度并运行，创建状态-->就绪态
        t.run();
    }

（5）main()和子线程同时运行，并打印观察执行顺序

public static void main(String[] args) throws InterruptedException {
       new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(999999999999999L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"第一个线程").start();
        System.out.println("main");
    }

执行过程：main申请系统调度子线程，因为还处于运行态，继续往下执行。系统调度到子线程，子线程运行态时，执行run方法中的代码

运行结果：从概率上看，“main”字符串打印的概率比较大。如果start（）调用以后，main的时间片刚好用完切换出去，子线程很快调度并运行，才会打印“第一个线程”

三、多线程的使用场景

1、提高效率

问题：（1）多线程一定能提高效率？（2）多线程什么时候能提高效率

2、有阻塞代码，需要同时执行其他代码

阻塞代码会导致当前线程有运行态—>阻塞态，导致后续代码无法执行
解决方法：将需要同步执行的代码放在新创建的线程中运行

四、创建线程

1、继承 Thread 类

通过继承 Thread 来创建一个线程类，该方法的好处是 this 代表的就是当前线程，不需要通过Thread.currentThread() 来获取当前线程的引用

class MyThread extends Thread {
	@Override
	public void run() {
		//这里是线程运行的代码
	}
}
MyThread t = new MyThread();
t.start(); // 线程开始运行

2、实现 Runnable 接口

通过实现 Runnable 接口，并且调用 Thread 的构造方法时将 Runnable 对象作为 target 参数传入来创建线程对象。

该方法的好处:可以规避类的单继承的限制；但需要通过Thread.currentThread() 来获取当前线程的引用

class MyRunnable implements Runnable {
	@Override
	public void run() {
		//这里是线程运行的代码
	}
} 
Thread t = new Thread(new MyRunnable());
t.start(); // 线程开始运行

3、其他变形

// 使用匿名类创建 Thread 子类对象
Thread t1 = new Thread() {
	@Override
	public void run() {
	//使用匿名类创建 Thread 子类对象
	}
};

// 使用匿名类创建 Runnable 子类对象
Thread t2 = new Thread(new Runnable() {
	@Override
	public void run() {
	//使用匿名类创建 Runnable 子类对象
	}
});

// 使用 lambda 表达式创建 Runnable 子类对象
Thread t3 = new Thread(() -> {

	}
);

Thread t4 = new Thread(() -> {
	//使用匿名类创建 Thread 子类对象
});