1. 程序、进程与线程
程序(program)：
为完成特定任务，用某种语言编写的 一组指令的集合。即指一段静态的代码，静态对象。
进程(process)：
程序的一次执行过程，或是正在内存中运行的应用程序。如: 运行中的QQ，运行中的网易音乐播放器。
- 每个进程都有一个独立的内存空间，系统运行一个程序即是一个进程从创建、运行到消亡的过程。(生命周期)
- 程序是静态的，进程是动态的
- 进程作为操作系统调度和分配资源的最小单位 (亦是系统运行程序的基本单位)，系统在运行时会为每个进程分配不同的内存区域
- 现代的操作系统，大都是支持多进程的，支持同时运行多个程序。
线程(thread)：
进程可进一步细化为线程，是程序内部的一条执行路径。一个进程中至少有一个线程。
- 一个进程同一时间若并行执行多个线程，就是支持多线程的。
- 线程作为CPU调度和执行的最小单位
- 一个进程中的多个线程共享相同的内存单元，它们从同一个堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来 安全的隐患
- 下图中，红框的蓝色区域为线程独享，黄色区域为线程共享
不同的进程之间是不共享内存的
进程之间的数据交换和通信的成本很高
2. 线程调度
分时调度
所有线程轮流使用 CPU 的使用权，并且平均分配每个线程占用CPU的时间
抢占式调度
让优先级高的线程以较大的概率优先使用CPU。如果线程的优先级相同，那么会随机选择一个线程随机性)，Java使用的为抢占式调度。
3. 多线程程序优点
背景：以单核CPU为例，只使用单个线程先后完成多个任务(调用多个方法)，肯定比用多个线程来完成用的时间更短（进程切换需要时间），为何仍需多线程呢?
多线程程序的优点：
- 提高应用程序的响应。对图形化界面更有意义，可增强用户体验
- 提高计算机系统CPU的利用率
- 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改
单核CPU，在一个时间单元内，只能执行一个线程的任务。要想提升系统的性能，要么提升CPU性能，要么多加几个CPU，即为多核的CPU。
4. 并行与并发
并行(parallel)：
指两个或多个事件在同一时刻发生（同时发生） 。指在同一时刻，有多条指令在多个CPU上同时执行。
并发(concurrency)：
指两个或多个事件在同一时间段内发生。即在一段时间内，有多条指令在单个CPU上快速轮换、交替执行，使得在宏观上具有多个进程同时执行的效果。
在操作系统中，启动了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单核 CPU 系统中，每一时刻只能有一个程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。
而在多核 CPU 系统中，则这些可以并发执行的程序便可以分配到多个CPU上，实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU，便是多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。
5. 创建和启动线程
Java语言的JVM允许程序运行多个线程，使用 java.lang.Thread 类代表线程，所有的线程对象都必须是Thread类或其子类的实例。
Thread类的特性：
- 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，因此把run()方法体称为线程执行体。
- 通过该Thread对象的start()方法来启动这个线程，而非直接调用run()
- 要想实现多线程，必须在主线程中创建新的线程对象。
5.1 方式一：继承Thread类
Java通过继承Thread类来创建并启动多线程的步骤如下：
- 定义Thread类的子类
- 重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务
- 创建Thread子类的实例，即创建了线程对象
- 调用线程对象的start()方法来启动该线程，start()会调用线程的run()方法
public class ThreadTest {
public static void main(String[] args) {
// 3. 创建Thread子类的实例
PrintNumber p1 = new PrintNumber();
// 4. 调用线程对象的start()方法来启动该线程
p1.start();
// 不能让已经start()的线程再次start()
// main()所在线程
for (int i = 1; i <= 1000; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ": " + i + "*");
}
}
// 创建另一个线程
PrintNumber p2 = new PrintNumber();
p2.start();
}
}
// 1. 定义Thread类的子类
class PrintNumber extends Thread {
// 2. 重写run()方法
@Override
public void run() {
for (int i = 1; i <= 1000; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}两个线程交互进行
5.2 方式二： 实现Runnable接口
- 创建一个实现Runnable接口的类
- 实现接口中的run()（两种方法的run方法不是同一个，实际上Thread类实现了Runnable接口的run方法）
- 创建当前实现类的对象
- 将此对象作为参数传递到Thread类的构造器中，创建Thread类的实例
- 调用start()
// 1. 创建一个实现Runnable接口的类
class EvenNumberPrinter implements Runnable {
// 2. 实现接口中的run()
@Override
public void run() {
for (int i = 1; i <= 1000; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
class ThreadTest1 {
public static void main(String[] args) {
// 3. 创建当前实现类的对象
EvenNumberPrinter p1 = new EvenNumberPrinter();
// 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的实例
Thread t1 = new Thread(p1);
// 5. 调用start()
t1.start();
// main()所在线程
for (int i = 1; i <= 1000; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ": " + i + "*");
}
}
// 创建另一个线程
Thread t2 = new Thread(p1);
t2.start();
}
}
6. 线程常用方法
6.1 线程中的构造器
public Thread()：分配一个新的线程对象。
public Thread(String name)：分配一个指定名字的新的线程对象。
public Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
public Thread(Runnable target, String name)：分配一个带有指定目标新的线程对象并指定名字6.2 线程中的常用方法
start()：启动线程；调用线程的run()
run()：将线程要执行的操作，声明在run()中
currentThread()：获取当前执行代码对应的线程
getName()：获取线程名
setName()：设置线程名
sleep(long millis)：静态方法，调用时，可以使得当前线程睡眠指定的毫秒数
yield()：静态方法，一旦执行此方法，就释放CPU的执行权
join()：在线程a中通过线程b调用该方法(b.join())，意味着线程a进入阻塞状态，直到线程b结束执行，线
程a才结束阻塞状态，继续执行
isAlive()：判断当前线程是否存活6.3 线程中的优先级
Thread类内部声明的三个常量
MAX_PRIORITY (10):最高优先级
MIN _PRIORITY (1):低优先级
MORM_PRIORITY (5):曹通忧先级，默认情况下main线程具有昔通优先级。
getPriority():获取线程的优先级
setPriority():设置线程的优先级。范围[1,10]7. 线程的生命周期
JDK1.5之前：5种状态
线程的生命周期有五种状态: 新建(ew) 、就绪(Runnable) 、运行(Running) 、阻塞(Blocked) 、死亡(Dead)。CPU需要在多条线程之间切换，于是线程状态会多次在运行、阻塞、就绪之间切换。
JDK1.5之后：
8. 线程的安全问题和同步机制
以售票为例
public class ThreadTest2 {
// 三个窗口同时售卖100张票
public static void main(String[] args) {
SaleTicket s = new SaleTicket();
Thread t1 = new Thread(s);
Thread t2 = new Thread(s);
Thread t3 = new Thread(s);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
class SaleTicket implements Runnable {
int ticket = 100;
@Override
public void run() {
while (true) {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "售票，票号为" + ticket);
ticket--;
} else {
break;
}
}
}
}
结合输出会发现有重票和错票，原因是线程1操作ticket的过程中，尚未结束的情况下，其他线程也参与进来，对tcket进行操作。因此，必须保证一个线程a在操作ticket的过程中，其它线程必须等待，直到线程a操作ticket结束以后，其它线程才可以继续操作ticket。
Java解决线程安全问题——使用线程的同步机制
8.1 同步代码块
synchronized(同步监视器) {
// 需要被同步的代码
}需要被同步的代码，即为操作共享数据的代码。
共享数据：即多个线程需要操作的数据。
需要被同步的代码，在被synchronized包裹后，就使得一个线程在操作这些代码的过程中，其他线程必须等待。
同步监视器，俗称锁。哪个线程获得了锁，哪个线程就能执行需要被同步的代码。
同步监视器可以使用任何一个类的对象充当，但是多个线程必须共用同一个同步监视器。
class SaleTicket implements Runnable {
int ticket = 100;
Object obj = new Object();
@Override
public void run() {
while (true) {
try {
Thread.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized(obj) {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "售票，票号为" + ticket);
ticket--;
} else {
break;
}
}
}
}
}8.2 同步方法
如果操作共享数据的代码完整的声明在了一个方法中，那么我们就可以将此方法声明为同步方法。
非静态的同步方法，默认监视器为this；静态的同步方法，监视器为当前类本身。
class SaleTicket implements Runnable {
int ticket = 100;
boolean isFlag = true;
@Override
public void run() {
while (isFlag) {
try {
Thread.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
show();
}
}
public synchronized void show() { // 此时默认监视器为this
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "售票，票号为" + ticket);
ticket--;
} else {
isFlag = false;
}
}
}