Java学习之路（八）：线程
一、基本概念：程序、进程、线程
- 程序（program）：是为完成特定任务、用某种语言编写的一组的指令的集合。即指
一段静态的代码，静态对象 - 进程（process）：是程序的一次执行过程，或是
正在运行的一个程序。是一个动态的的过程：有它自身的产生、存在和消亡的过程——生命周期
① 例如：运行中的QQ，MP3
② 程序是静态的，进程是动态
③进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 - 线程（thread）：进程可进一步细化为线程，
是一个程序内部的一条执行路径
① 若一个进程同一时间并行多个线程，就是支持多线程的
②线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc），线程切换的开销小
③ 一个进程中的多个线程共享相同的内存单元/内存空间地址--> 它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能会带来安全隐患。
- 单核CPU和多核CPU的理解
- 单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务，例如:虽然有多车道，但是收费站只有一一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以把他“挂起”(晾着他， 等他想通了，准备好于钱，再去收费)。但是因为CPU时间单元特别短，因此感觉不出来。
例如： 一个Java应用程序java.exe， 其实至少有三个线程: main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。
- 如果是多核CPU，才能更好的发挥多线程的效率。（现在的服务器都是多核的）
- 并行与并发
- 并行：多个CPU同时执行多个任务。比如多个人同时做不同的事
- 并发：一个CPU（采用时间片）'同时’执行多个任务。比如：秒杀、多个人同时做同一件事
二、线程的创建和使用
- 使用多线程的优点
- 提高应用程序的响应。对图形化界面更有意义，可增强用户体验
- 提高计算机系统CPU的利用率
- 改善程序结构。将即长又复杂的进程分为多个线程，独立运行，利于理解和修改
- 何时需要多线程
- 程序需要同时执行两个或多个任务
- 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等
- 需要一些后台运行的程序时
1.Thread类的特性
- 每个线程都是通过某个特定的Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
- 通过该Thread对象的start()方法来启动这个线程，而非直接调用run()
2.创建多线程之方式一：继承于Thread类
步骤
- 创建一个基础于Thread类的子类
- 重写Thread类的run() ——> 将此线程执行的操作声明在run()中
- 创建Thread类的子类的对象
- 通过此对象调用start()：①启动当前线程，②调用当前线程的run()
package com.zc.test.thread;
/**
* @author ZC
* @Description 创建多线程方式一
* @date 2020-06-29 11:49
*/
//1. 创建继承于Thread类的子类
class MyThread extends Thread{
//2.重写Thread中的run()
@Override
public void run() {
for (int i = 0;i < 100 ;i++){
if ( i%2 == 0){
System.out.println(i);
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {
//创建子类的对象
MyThread myThread = new MyThread();
//调用该对象的start方法：①启动当前线程，②调用当前线程的run()
myThread.start();
for (int i = 0;i < 100 ;i++){
if ( i%2 == 0){
System.out.println(i+"____——————————————————");
}
}
}
}
注意：
- 我们不能通过直接调用run()的方式启动线程
- 再启动一个线程，不可以还让已经start()的线程在此start()，不然会报IllegalThreadStatu
3. Thread类的有关方法
- void start()：启动线程，并执行对象的run()方法
- run()：线程在被调度的时候执行的操作，通常子类需要重写该方法
- String getName()：返回线程的名字
- void setName(String name)：设置该线程的名字
- static Thread currentThread()：返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
- static void yield()：释放当前CPU的执行权
- final void join()：在线程a中调用线程b的join()方法，此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态
- void stop：已过时，当执行此方法时，强制结束当前线程
- static void sleep(long millis)：使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行/睡眠)
10.boolean isAlive() ： 判断当前线程是否存活
4. 线程的调度
①调度策略
- 时间片
- 抢占式：高优先级的线程抢占CPU
②Java的调度方法
- 同优先级的线程组成先进先出队列（先到先服务），使用时间片策略
- 对搞优先级，使用优先调度的抢占式策略
③线程的优先级等级
注意：高优先级的线程抢占低优先级线程的CPU的执行权，但只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行
a. MAX_PRIORITY：10
b. MIN_PRIORITY：1
c. NORM_PRIORITY：5 —> 默认优先级
④如何获取和设置当前线程的优先级
a. getPriority()：获取线程的优先级
b. setPriority(int p)：设置线程的优先级
5.创建多线程之方式二：实现Runnable接口
步骤
- 创建一个实现了Runable接口的实现类
- 实现类去实现Runable接口的抽象方法：run()
- 创建实现类的对象
- 将实现类的对象作为参数传递到Thread类的构造器中，创建一个Thread类的对象
5.通过Thread类的对象调用start方法
package com.zc.test.thread;
/**
* @author ZC
* @Description 创建多线程的方式二
* @date 2020-06-29 16:33
*/
//1.创建实现了Runable接口的实现类
class MyThread2 implements Runnable{
//2.实现Runable的抽象方法：run()
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"______"+i);
}
}
}
public class ThreadTest3 {
public static void main(String[] args) {
//3.创建实现类的对象
Runnable r = new MyThread2();
//4.将实现类的对象作为参数传递给Thread的构造器，创建Thread类的对象
Thread thread = new Thread(r);
//5.调用Thread类的对象的start()：①启动线程，②调用当前线程的run()——>调用了Runable类型的target的run(0
thread.start();
//再启动一个线程
Thread thread1 = new Thread(r);
thread1.start();
}
}
6.比较创建线程的两种方式
- 开发中：优先选择：实现Runable接口的方式
- 原因：
- 实现的方式没有类的单继承性的局限
- 实现的方式更适合来处理多个线程有共享数据的情况
- 联系：
public class Thread implements Runable - 相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中
三、线程的生命周期
-
JDK中用Thread。State枚举类定义了线程的几种状态。（
NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED） -
一个线程在其完整的生命周期通常要经历以下5种状态
新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已经具备了运行的条件，只是没有分配到CPU资源运行：当就绪的线程被调度并获得CPU资源时，并进入运行状态，run()方法定义了线程的操作和功能阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态死亡：线程完成了它全部的工作或线程被提前强制性中止或出现异常导致结束
四、线程的同步
1. 线程安全问题
- 多个线程执行的不确定性引起执行结果的不稳定
- 多个线程对数据的共享，会造成操作的不完整性，对数据造成破坏
2.在Java中通过同步机制（synchronized）来解决线程的安全问题
方式一、同步代码块
synchronuzed(同步监视器){
//需要被同步的代码（即操作共享数据的代码，不能包含代码多了，也不能包含代码少了）
}
在继承Thread类创建的多线程的方式下，慎用this充当同步监视器，考虑使用当前类充当同步监视器
在实现Runable接口创建的多线程的方式下，考虑使用this充当同步监视器
- 操作共享数据的代码，不能包含代码多了，也不能包含代码少了
- 共享数据：多个线程共同操作的变量
- 同步监视器，俗称 锁。任何一个类的对象都能充当锁(
要求：多个线程必须同用一把锁)
方式二、同步方法
权限修饰符 [static] synchronized 返回类型 方法名(形参列表){//同步监视器就是this
方法体
}
- 如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明为同步的
- 关于同步方法的总结：‘
- 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明
- 非静态的同步方法，同步监视器：this
静态的同步方法，同步监视器：当前类本身
- 同步的方式，解决了线程的安全问题 —— 好处
- 操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程。效率低 —— 局限性
3. 线程的死锁问题
- 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
- 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
- 解决的方法：
①专门的算法、原则
②尽量减少同步资源的定义
③尽量避免同步嵌套
4. Lock（锁）
- 从JDK5.0开始，Java提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显示加锁、释放锁。- 步骤：
①实例化ReentrantLock类
private ReentrantLock lock = new ReentrantLock();
②调用锁定方法lock()
lock.lock();
③调用解锁方法unlock()
lock.unlock();
package com.zc.test.thread;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author ZC
* @Description 解决线程安全问题的方式三：Lock锁 ———— JDK5.0新增
* @date 2020-06-29 23:05
*/
public class LockTest {
public static void main(String[] args) {
Runnable w = new Window_s4();
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_s4 implements Runnable{
private int ticket = 100;
// 1. 实例化ReentrantLock类
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
for (int i = 0; i < 100; i++) {
try{
//2. 调用锁定方法lock()
lock.lock();
if (ticket > 0){
System.out.println(Thread.currentThread().getName()+"卖票咯，票号："+ticket);
ticket--;
}else{
break;
}
}finally {
//3.调用解锁方法unlock()
lock.unlock();
}
}
}
}
5. synchronzied和Lock的异同
Java学习之路（三）：不同结构的区别(更新中) ——第11点
6.优先使用顺序
Lock —> 同步代码块（已经进入了方法体，分配了相应资源） —> 同步方法（在方法体之外）
五、线程的通信
- 涉及到的三个方法
wait()：一旦执行此方法，线程会进入阻塞状态，并释放同步监视器notify()：一旦执行此方法，就会唤醒被wait的一个线程，如果有多个线程被wait，就会唤醒优先级高的线程notifyAll()：一旦执行此方法，就会唤醒所有被wait的线程
- 说明
- wait()、notify()、notifyAll()这三个方法必须使用在同步代码块或同步方法中
- wait()、notify()、notifyAll()这三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则，会出现
java.lang.IllegalMonitorStateException异常 - wait()、notify()、notifyAll()这三个方法是定义在java.lang.Object类中（因为任何一个类的对象都可以充当同步监视器）
- 例子：
package com.zc.test.thread;
/**
* @author ZC
* @Description 线程通信的例子：使用两个线程打印1-100，线程1和线程2交替打印
* @date 2020-06-30 9:40
*/
public class CommunitcationTest {
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();
}
}
class Number_ implements Runnable {
private int number = 1;
@Override
public void run() {
while(true){
synchronized (this) {
notify();//唤醒执行wait方法的线程
if (number <= 100){
System.out.println(Thread.currentThread().getName()+":"+number);
number++;
try {
//使得调用如下wait()方法的线程进入阻塞状态，执行wait会释放锁
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
break;
}
}
}
}
}
六、JDK5.0新增线程创建方式
1. 创建多线程之方式三：实现Callable接口
- 与Runnable相比，Callble功能更强大写
- 相比run()方法，
可以有返回值- 方法
可以抛异常,被外面的操作捕获，获取异常信息支持泛型的返回值- 需要借助FutureTask类，比如获取返回结果
- Future接口
- 可以对具体Runable、Callable任务的执行接口进行取消、查询是否完成、获取结果等。
- FutureTask是Future接口的唯一实现类
- FutureTask同时实现了Runable和Future接口。它既可以作为Runable被线程执行，又可以作为Future得到Callable的返回值
步骤：
- 创建Callable接口的实现类
- 实现Callable接口中的call()方法，将此线程需要执行的操作声明在call()中
- 创建Callable实现类的对象
- 将Callable实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
- 将FutureTask的对象作为参数传递到Thread的构造器中，创建Thread的对象，并调用start()
- 可通过FutureTask对象的get()方法获取Callable中call()的返回值
package com.zc.test.thread;
/**
* @Description 创建线程的方式三：实现Callable接口 JDK5.0新增
* @author ZC
* @date 2020-06-30 11:17
*/
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class ThreadNew {
public static void main(String[] args) {
// 3.创建Callable实现类的对象
NumThread numThread = new NumThread();
// 4.将Callable实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
FutureTask task = new FutureTask(numThread);
// 5.将FutureTask的对象作为参数传递到Thread的构造器中，创建Thread的对象，并调用start()
new Thread(task).start();
try {
//6.可通过FutureTask对象的get()方法获取Callable中call()的返回值
//get()返回值即为FutureTask构造器参数Callable对象的call()方法的返回值
Object o = task.get();
System.out.println("总和为："+o);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
//1. 创建Callable接口的实现类
class NumThread implements Callable{
//2.实现Callable接口中的call()方法，将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 0; i < 100; i++) {
System.out.println(i);
sum += i;
}
return sum;
}
}
2.创建多线程之方式四：使用线程池
- 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能的影响很大。
- 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完返回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具
- 好处
- 提高响应速度（减少了创建新线程的时间）
- 降低资源消耗（重复利用线程池中的线程，不需要每次都创建）
- 便于线程管理
① corePoolSize：核心池的大小
② maximumPoolSize：最大线程数
③ keepAliveTime：线程没有任务时最多保持多长时间后会终止
。。。。
-
JDK5.0起提供了线程池相关API：
ExecutorService和Executors -
ExecutorService:真正的线程池接口。常见于子类ThreadPoolExecutor
- void execute(Runable command)：执行任务/命令，没有返回值，一般用来执行Runable
- Future submit(Callable task): 执行任务/命令，有返回值，一般用来执行Callable
- void shutdown()：关闭连接池
-
Executors：工具类，线程池的工厂类，用于创建并返回不同类型的线程池
- Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
- Executors.newFixedThreadPool(n)：创建一个可重用固定线程数的线程池
- Executors.newSingleThreadExecutor()：创建一个只有一个线程的线程池
- Executors.newScheduledThreadPool(n)：创建一个线程池，他可安排在给定延迟后运行命令或者定期的执行
-
步骤
- 创建指定数量的线程池
- 执行指定线程的操作,需要提供Runnable接口或Callable接口的对象作为参数
package com.zc.test.thread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @Description 创建线程的方式四：使用线程池
* @author ZC
* @date 2020-06-30 12:04
*/
public class ThreadPool {
public static void main(String[] args) {
//1.创建指定数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
//设置线程池的属性
/*ThreadPoolExecutor service1 = (ThreadPoolExecutor)service;
service1.setCorePoolSize();
service1.setKeepAliveTime();
service1.setMaximumPoolSize();
service1.setRejectedExecutionHandler();
service1.setThreadFactory();*/
//2.执行指定线程的操作,需要提供Runnable接口或Callable接口的对象作为参数
service.execute(new NumberThread());//适合适用于Runnable
service.submit(new NumberThread2());//适合适用于Callable
//关闭连接池
service.shutdown();
}
}
class NumberThread implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
class NumberThread2 implements Callable {
@Override
public Object call() {
for (int i = 100; i < 200; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
return null;
}
}