开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第5天，点击查看活动详情

程序、进程、线程

程序

为完成特定的任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程

是程序的一次执行过程，或者是正在运行的一个程序。

是一个动态的过程：有它自身的产生、存在和消亡的过程。即生命周期

进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

线程：进程可进一步细化为线程，是一个程序内部的一条执行路径。

若一个进程同一时间并行执行多个线程（可以说进程有多个执行路径），那么我们说这个程序是支持多线程的

线程作为执行和资源调度的单位，每个线程拥有独立的运行栈和程序计数器（pc），线程切换的开销小。

总结：程序的执行过程叫一次进程，进程可以由多个线程同时执行，提高执行效率。

单核与多核CPU

单核CPU

就是只有一个核能够进行数据的处理

实际上是一种假的多线程。单核执行过程：比如高速收费站，加入只有一个收费点，但是突然有一个人不想交钱，那么工作人员可以把他“挂起来”，让后面的车交钱通过；

因为时间单元特别短，所以感觉上是多线程。

多核CPU

同一个时间可以做多个事情，现在的服务器都是多核的

并行与并发

并行：多个CPU同时执行多个任务；比如：多个人同时做不同的事
并发：一个CPU“同时”（实际上是切换时间短）执行多个任务。比如：秒杀、多个人做同一个事

多线程优点

提高应用程序的相应
提高计算机系统CPU的利用率
改善程序结构

线程的创建和使用

继承于Thread类

方式：

创建一个继承于Thread类的子类
重写Thread类的run()方法 -->将此线程要执行的操作声明在重写的run()方法中
创建子类的对象
通过此对象调用start()方法：作用①启动此线程②调用当前线程的run()方法。

🎈举例：遍历100以内偶数

//1. 创建一个继承于Thread类的子类
class MyThread extends Thread{
	//2. 重写Thread类的run()方法
	public void run() {
		for(int i = 1;i<100;i++) {
			if(i%2 == 0) {
				System.out.print(i + " ");
			}
		}
	}
}

public class ThreadTest {
	public static void main(String[] args) {
		//3. 创建子类的对象
		MyThread t1 = new MyThread();
		//4. 通过此对象调用start()方法
		t1.start();
	}
}

注意：

我们启动一个线程，必须调用start()，不能调用run()的方式启动线程。

如果再启动一个线程，必须重新创建一个Thread子类的对象，调用此对象的start()

Thread.currentThread().getName()获取线程名字的方法

当然，也可以通过创建Thread匿名子类的对象去创建线程

new Thread(){
    public void run(){
        //重写内容
    }
}.start;

线程的常用方法

start()：启动线程，并执行对象的run()方法
run()：线程在被调度时执行的操作
getName()：获取当前线程的名称
setName(String name)：设置该线程名称
static Thread currentThread()：静态方法，返回执行当前代码的线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
yield()：线程让步；释放当前cpu的执行权👇

暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程

若队列中没有同优先级的线程，忽略此方法

join()：在线程a中调用线程b的join()方法后，线程a进入阻塞状态，等执行完线程b之后再执行线程a，结束线程a的阻塞状态👇

低优先级的线程也可以获得执行

sleep(long millis)：(指定时间:毫秒)👇

在指定的毫秒内，当前线程处于阻塞状态

抛出InterruptedException异常

stop()：强制线程生命期结束，不推荐使用
boolean isAlive()：返回boolean，判断线程是否还活着

下面是其中一些方法的举例：

class HelloThread extends Thread{
	@Override
	public void run() {
		for(int i = 1;i<100;i++) {
			if(i%2 == 0) {
				
				try {
					sleep(10);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
				System.out.println(Thread.currentThread().getName() + ":" + i);
			}
			
			if(i % 20 == 0) {
				yield();
			}
		}
	}
}

public class ThreadMethodTest {
	public static void main(String[] args) {
		HelloThread h1 = new HelloThread();
		h1.setName("线程一");
		h1.start();
		
		
		//给主线程命名
		Thread.currentThread().setName("主线程");
		for(int i = 1;i<100;i++) {
			if(i%2 == 0) {
				System.out.println(Thread.currentThread().getName() + ":" + i);
			}
			//join方法让h1这个线程优先执行完，程序再继续执行主线程
			if(i == 20) {
				try {
					h1.join();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
		
		System.out.println(h1.isAlive());
	}
}

线程的调度

调度的策略：

时间片：一会执行a一会执行b
抢占式：高优先级的线程抢占CPU

Java的调度方法

同优先级线程组成先进先出队列（先到先服务），使用时间片策略
对高优先级，使用优先调度的抢占式策略

线程的优先级等级

有三个常量表示优先级等级，定义在Thread类中

MAX_PRIORITY:10

MIN_PRIORITY: 1

NORM_PRIORITY: 5（默认的优先级）

如何获取和设置优先级

getPriority()：获取线程的优先级
setPriority(int p)：设置线程的优先级设置一定要在start()方法之前设置

注意：并不是优先级高就代表先执行完，也会出现交互，甚至优先级高的后执行

实现Runnable接口

创建一个实现了Runnable接口的类
实现类去实现RunnabLe中的抽象方法: run( )
创建实现类的对象
将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
通过Thread类的对象调用start()

//1. 创建一个实现了Runnable接口的类
class MThread implements Runnable{
	//2. 实现类去实现RunnabLe中的抽象方法: run( )
	@Override
	public void run() {
		for(int i =0;i < 100 ;i++) {
			if(i % 2 == 0) {
				System.out.println(i);
			}
		}
	}	
}

public class RunnableTest {
	public static void main(String[] args) {
		//3. 创建实现类的对象
		MThread m1 = new MThread();
		//4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
		Thread t1 = new Thread(m1);
		//5. 通过Thread类的对象调用start()
		t1.start();
	}
}

比较两种创建线程的方式

开发中：优先选择实现Runnable接口的方式

原因：

实现的方式没有类的单继承性的局限性
更适合用来处理多个线程有共享数据的情况联系：
Thread类源码中其实也是实现了Runnable接口相同点：两种方式都需要重写run()，将线程要执行的逻辑声明在run()中

线程的生命周期

JKD中用Thread.State类定义了线程的几种状态

线程在它的一个完整的生命周期中通常要经历五种状态：

新建：Thread类或它的子类的对象被声明并创建时
就绪：被start()后
运行：就绪的线程被调度并获得CPU资源时
阻塞：让出CPU并临时中止自己的执行
死亡：线程完成自己的全部工作或被强制中止或异常导致

线程的同步（线程安全）

这种安全问题来源于操作共享的数据。

比如，你的银行卡只有三千，你现在和另外一个人同时用这张银行卡取两千，如果没有线程安全，则你们都会取成功，那银行是不是就会亏？

同步代码块处理实现Runnable接口

示例在下面卖票窗口练习处。

synchronized(同步监视器){ //需要被同步的代码 }

需要被同步的代码：操作共享数据的代码
同步监视器：俗称：锁。任何一个类的对象都可以充当锁；要求是多个线程必须要共用同一把锁。

同步方法处理继承Thread类

同步方法仍然涉及到同步监视器，只是不需要我们显式地声明
非静态的同步方法，同步监视器是：this；静态的同步方法，同步监视器是：当前类本身

卖票窗口（练习）

问题：卖票过程中，出现了重票、错票；即线程安全问题
原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票
如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket的时候，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。
在Java中，我们通过同步机制来解决线程安全问题方式一：同步代码块(synchronized)

class Window implements Runnable{
	private static int ticket  = 100;
	Object obj = new Object();
	@Override
	public void run() {
		while(true) {
			synchronized(obj) {				
				if(ticket > 0) {					
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					
					System.out.println(Thread.currentThread().getName() + ": 卖票，票号为:" + ticket);
					ticket--;
				} else {
					break;
				}
			}
		}
	}
	
}

public class WindowTest {
	public static void main(String[] args) {
		Window w = new Window();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        
        t1.start();
        t2.start();
        t3.start();
	}	
}

方式二：同步方法

class Window extends Thread{
	private static int ticket  = 100;
	Object obj = new Object();
	@Override
	public void run() {
		while(true) {		
			show();			
		}
	}
	
	private static synchronized void show() {
		if(ticket > 0) {					
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
			System.out.println(Thread.currentThread().getName() + ": 卖票，票号为:" + ticket);
			ticket--;
		} 		
	}
	
}

public class WindowTest {
	public static void main(String[] args) {
		Window t1 = new Window();
		Window t2 = new Window();
		Window t3 = new Window();


        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        
        t1.start();
        t2.start();
        t3.start();
	}	
}

同步的方式，解决了线程的安全问题-->好处

操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。 --->局限性

线程安全的懒汉式

使用同步机制将单例模式中的懒汉式改写为线程安全的

class Bank{
	private Bank() {
		
	}
	
	private static Bank instance = null;
	
	public static synchronized Bank getInstance() {
		//方式一：效率稍差
/*			synchronized(Bank.class) {			
				if(instance == null) {			
					instance = new Bank();
				}
				return instance;
			}   
*/
		//方式二：效率更高
		if(instance == null) {
			synchronized(Bank.class) {			
				if(instance == null) {			
					instance = new Bank();
				}
				return instance;
			} 
		}
	}
}

死锁

概念：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了死锁。

出现死锁后，不会出现异常，不会有提示，只是所有的线程都处于阻塞状态，无法继续。

解决方法：

专门的算法、原则
进来减少同步资源的定义
进来避免嵌套同步

下面演示一个死锁

public class ThreadTest {
	public static void main(String[] args) {
		
		StringBuffer s1 = new StringBuffer();
		StringBuffer s2 = new StringBuffer();
		
		new Thread() {
			@Override
			public void run() {
				synchronized(s1) {
					s1.append("a");
					s2.append("1");
					
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					
					synchronized (s2) {
						s1.append("b");
						s2.append("2");
						
						System.out.println(s1);
						System.out.println(s2);
					}
				}
			}			
		}.start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				synchronized(s2) {
					s1.append("c");
					s2.append("3");
					
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					
					synchronized (s1) {
						s1.append("d");
						s2.append("4");
						
						System.out.println(s1);
						System.out.println(s2);
					}
				}
			}
		}).start();
	}
}

Lock(锁)

Lock也是解决线程安全问题的一种方式。之前讲过同步代码块和同步方法。

实例化ReentrantLock
调用锁定方法lock()
调用解锁方法unlock()

class Window implements Runnable{
	private int ticket = 100;
	//1.实例化ReentrantLock
	private ReentrantLock lock = new ReentrantLock();
	@Override
	public void run() {
		while(true) {
			try {
				//2.调用锁定方法lock()
				lock.lock();
				if(ticket > 0) {
					
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					
					System.out.println(Thread.currentThread().getName() + "售票，票号为" + ticket);
					ticket--;
				} else {
					break;
				}
			} finally {
				//3.调用解锁方法unlock()
				lock.unlock();
			}
		}
	}
}

public class LockTest {
	public static void main(String[] args) {
		Window w = new Window();
		
		Thread t1 = new Thread(w);
		Thread t2 = new Thread(w);
		Thread t3 = new Thread(w);


        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        
        t1.start();
        t2.start();
        t3.start();
	}
}

🎈面试题：synchronized与Lock的异同

同：都可以解决线程安全的问题
异：synchronized机制是在执行完相应的同步代码以后，自动地释放同步监视器；而Lock需要手动地启动同步（lock()），同时结束同步也是去手动实现（unlock()）

优先使用顺序： Lock->同步代码块（已经进入了方法体，分配了相应资源）->同步方法（在方法体之外）

线程的通信

就是多个线程交替打印

涉及到的三个的方法：

wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
notifyAll():一旦执行此方法，就会唤醒所有被wait的方法。

例子：使用两个线程打印1-100。并且要交替打印

class Number implements Runnable{
	private int number = 1;

	@Override
	public void run() {
		while(true) {
			synchronized (this) {
				
				notify();//多个线程用notifyAll()
				
				if (number <= 100) {
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					
					System.out.println(Thread.currentThread().getName() + ":" + number);
					number++;
					
					try {
						//使调用wait()方法的线程进入阻塞状态
						wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					
				} else {
					break;
				}
			}
		}
	}
	
}
public class CommunicationTest {
	public static void main(String[] args) {
		Number number = new Number();
		Thread t1 = new Thread(number);
		Thread t2 = new Thread(number);
		
		t1.setName("线程1");
		t2.setName("线程2");
		
		t1.start();
		t2.start();
	}
}

说明：

wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
三个方法的调用者必须是同步代码块或是同步方法中的同步监视器

sleep和wait的异同

同：一旦执行方法，都可以使当前线程进入阻塞状态
异：

两个方法的声明位置不同：Thread类中声明sleep()，Object类中声明wait()
调用的要求不同：sleep()可以在任何需要的场景下使用。wait()必须使用在同步代码块或是同步方法中。
关于是否释放同步监视器：如果两个方法都使用在同步代码块或是同步方法中，sleep()不会释放锁，而wait()会。

新增的线程创建方式

下面两种方式是JDK5.0之后新增的

实现Callable接口
使用线程池

实现Callable接口

与Runnable相比，Callable功能更强大：

相比run()方法，可以有返回值了。重写的是call()方法
方法可以抛出异常
支持泛型的返回值
需要借助FutureTask类，比如获取返回结果

既然需要借助FutureTask类，就要提一下Future接口：

可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。

FutureTask是Future接口的唯一实现类

FutureTask同时实现了Runnable，Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值

👇比如遍历100以内的偶数

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

//1.创建一个实现Callable的实现类
class NumThread implements Callable{
	//2.实现call()方法，将此线程需要执行的操作声明在call()中
	@Override
	public Object call() throws Exception {
		int sum = 0;
		for (int i = 1; i <= 100; i++) {
			if(i % 2 == 0) {
				System.out.println(i);
				sum += i;
			}
		}
		return sum;
	}
	
}

public class ThreadNew {
	public static void main(String[] args) {
		//3.创建Callable接口实现类的对象
		NumThread numThread = new NumThread();
		//4.将此Callable接口实现类的对象作为参数传递到FutureTask构造器中
		//创建FutureTask的对象
		FutureTask futureTask = new FutureTask(numThread);
		//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
		new Thread(futureTask).start();
		
		try {
			//6.获取Callable中call方法的返回值  -->可选
			//get()返回值即为FutureTask构造器参数Callable实现类重写的call方法的返回值
			Object sum = futureTask.get();
			System.out.println("总和:" + sum);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

线程池*

开发中其实都用线程池

思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的交通工具

好处：

提高响应速度（减少了创建新线程的时间）
降低资源消耗（重复利用线程池中线程，不需要每次都创建）
便于线程管理👇
- corePoolSize：核心池的大小
- maximumPoolSize：最大线程数
- keepAliveTime：线程没有任务时最多保持多长时间后会终止

线程相关的API：ExecutorService 和 Executors

Executors.newCachedThreadPool():创建一个可根据需要创建新线程的线程池
Executors.newFixedThreadPool(n):创建一个可重用固定线程数的线程池
Executors.newSingleThreadExecutor():创建一个只有一个线程的线程池
Executors.newScheduledThreadPool(n):创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行

ThreadPoolExecutor，这是接口实现的类，可以通过创建这个类的对象，调用上方便于线程管理的方法。

class NumberThread implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

class NumberThread1 implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

public class ThreadPool {

    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();


        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable

//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }

}

Java多线程