Java高级

Java高级

多线程

• 基本概念：程序、进程、线程
• • 程序(program)
  • 进程(process)
  • 线程(thread)
  • 单核CPU和多核CPU
  • 并行与并发
  • • 并行
    • 并发
  • 使用多线程的优点
  • 何时需要多线程
• `线程的创建和使用`
• • 创建线程的方式一：继承于Thread类
  • • 注意
    • Thread中的常用方法
    • 线程的调度
    • • 线程的优先级等级
      • 涉及的方法
  • 创建线程的方式二：实现Runnable接口
  • 比较两种创建线程的方式
• 线程的生命周期
• • 新建
  • 就绪
  • 运行
  • 阻塞
  • 死亡
  • `线程的同步`
  • • 解决线程安全问题的方式一：同步代码块
    • 解决线程安全问题的方式二：同步方法
  • 说明
  • • 单例模式的饿汉式线程完全的写法
  • 线程的死锁
  • • 死锁
    • 产生死锁的四个必要条件
    • 解决方法
    • 解决线程安全问题的方式三：Lock锁---JDK5.0新增
• 线程的通信
• JDK5.0新增线程创建方式
• • 创建线程的方式三：实现Callable接口
  • • 实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大体现在何处
  • 创建线程的方式四：使用线程池

基本概念：程序、进程、线程

程序(program)

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

进程(process)

是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、生存和消亡的过程–声明周期

线程(thread)

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

• 若一个进程同一时间并行执行多个线程，就是支持多线程的
• 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(PC)，线程切换的开销小
• 一个进程中的多个线程共享相同的内存单元/内存地址空间–>它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患

单核CPU和多核CPU

…
一个Java应用程序，至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当异常发生是，会影响主线程

并行与并发

并行

多个CPU同时执行多个任务。比如：多个人同时做不同的事

并发

一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。

使用多线程的优点

• 1、提高应用程序的响应。对图形化界面更有意义，可增强用户体验
• 2、提高计算机CPU的利用率
• 3、改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

何时需要多线程

• 程序需要同时执行两个或多个任务时
• 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
• 需要一些后台运行的程序时

线程的创建和使用

创建线程的方式一：继承于Thread类

步骤：

• 1、创建一个继承于Thread类的子类
• 2、重写Thread类中的run()方法
• 3、创建Thread类的子类的对象
• 4、通过此对象调用Thread类中的start()方法
  start()方法：
  • a、启动当前线程。
  • b、调用当前线程的run()

注意

• 1、启动线程只能调用start()方法，不能调用run()
• 2、要启用多个线程，就得需要new不同的对象来调start()

Thread中的常用方法

• 1、start()：启动当前线程；调用当前线程的run()
• 2、run()：通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
• 3、currentThread()：静态方法，返回执行当前代码的线程
• 4、getName()：获取当前线程的名字
• 5、setName()：设置当前线程的名字
• 6、yield()：释放当前CPU的执行
• 7、join()：在线程a中调用线程b的join()，此时线程a 就进入阻塞状态，知道线程b执行完成以后，线程a才结束阻塞状态。
• 8、stop()：已过时。当执行此方法时，强制结束当前线程
• 9、sleep(long millitime)：让当前线程"睡眠/阻塞"指定的millitime毫秒的时间内，当前线程是阻塞状态。
• 10、isAlive()：判断当前线程是否还存活，返回boolean值

线程的调度

线程的优先级等级

MAX_PRIORITY:10
MIN_PRIORITY:1
NORM_PRIORITY:5

涉及的方法

• getPriority():返回线程优先值
• setPriority(int newPriority):改变线程的优先级

说明：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。

创建线程的方式二：实现Runnable接口

步骤：

• 1、创建一个实现了Runnable接口的类
• 2、实现类去实现Runnalbe中的抽象方法：run()
• 3、创建实现类的对象
• 4、将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
• 5、通过Thread类的对象调用start()

比较两种创建线程的方式

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

• 1、实现的方式没有类的单继承性的局限
• 2、实现的方式更适合来处理多个线程有共享数据的情况

联系：public class Thread implements Runnable(Thread本身也是实现的Runnable接口)
相同点：两种方式都需要重写run()，将线程要执行的逻辑声明在run()中

线程的生命周期

线程的生命周期通常经历五种状态：新建、就绪、运行、阻塞、死亡

新建

当一个Thread类或其子类的对象被声明并创建时，新生的线程对像处于新建状态

就绪

处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源

运行

当就绪的线程被调度并获得CPU资源时，便进入运行状态，run()方法定义了线程的操作和功能

阻塞

在某种特殊情况下，被认为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态

死亡

线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

线程的同步

线程同步主要就是解决线程安全的问题

解决线程安全问题的方式一：同步代码块

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

说明：

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

补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
在继承Thread类创建多线程的方式中，慎用this充当同步监视器，可以考虑使用当前类(当前类的类名.class)充当同步监视器

解决线程安全问题的方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的

• 1、同步方法仍然涉及到同步监视器，只是不需要我们显示的声明
• 2、非静态的同步方法，同步监视器是:this

 @Overridepublic void run() {while(true){show();}}public synchronized void show(){//这里的同步监视器是：this
//    public void show(){
//        synchronized(this){if(ticket > 0){try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);ticket--;}//没有break用于跳出上面的while循环}}

静态的同步方法，同步监视器是：当前类本身

 @Overridepublic void run() {while(true){show();}}public static synchronized void show(){//同步监视器：Window4.class。类本身if(ticket > 0){try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+":卖票，票号为："+ticket);ticket--;}//没有break用于跳出上面的while循环}

说明

同步的方式，解决了线程的安全问题。—>好处
操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。—>局限性

单例模式的饿汉式线程完全的写法

/**** 使用同步机制将单例模式中的懒汉式改写为线程完全的** @author LawrenceLan* @create 2022--09--22--21:45*/
public class BankTest {
}class Bank {private Bank() {}private static Bank instance = null;private static 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;}
}

线程的死锁

死锁

• 1、死锁的理解：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
• 2、说明：
  • a、出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
  • b、我们使用同步时，要避免出现死锁

产生死锁的四个必要条件

• 1、互斥条件：该资源在任意时刻都只由一个线程占用
• 2、请求与保持条件：一个线程在申请某个资源时产生了阻塞，而已占有的资源保持不放
• 3、不剥夺条件：线程在已获得的资源在未使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源
• 4、循环等待条件：若然进程之间形成一种头尾相接的循环等待资源关系

解决方法

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

• 1、破坏互斥条件：这个条件我们没有办法破坏，因为我们用锁本来就是想让他们互斥的（临界资源需要互斥访问）
• 2、破坏请求与保持条件：一次性申请所有的资源
• 3、破坏不被剥夺条件：占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源
• 4、破坏循环等待条件：靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放。

解决线程安全问题的方式三：Lock锁—JDK5.0新增

步骤：

• 1、实例化ReentrantLock
• 2、ReentrantLock的对象调用lock()方法，上锁
• 3、ReentrantLock的对象调用unlock()方法，解锁
  代码实例：
  import urrent.locks.ReentrantLock;

import urrent.locks.ReentrantLock;/**** 解决线程完全问题的方式三：Lock锁---JDK5.0新增** @author LawrenceLan* @create 2022--09--22--22:46*/class Window implements Runnable{private int ticket = 1000;//1、实例化ReentrantLockprivate ReentrantLock lock =new ReentrantLock();@Overridepublic void run() {while(true){try{//2.调用lock()方法。线程进来后，锁定，保证一次只有一个线程进代码块来lock.lock();if(ticket > 0){try {Thread.sleep(10);} catch (InterruptedException e) {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 w1 = new Window();Thread t1 =new Thread(w1);Thread t2 =new Thread(w1);Thread t3 =new Thread(w1);t1.setName("窗口1：");t2.setName("窗口2：");t3.setName("窗口3：");t1.start();t2.start();t3.start();}
}

面试题：synchronized和Losk的异同？
相同：二者都可以解决线程安全问题
不同：

• Lock是显示锁（手动开启和关闭锁），synchronized是隐式锁，出了作用域自动释放同步监视器
• Lock只有代码块锁，synchronized有代码块锁和方法锁(同步方法注意跳出循环的问题)
• 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）

线程的通信

涉及到三个方法：

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

说明：

• 1、wait()、notify()、notifyAll()三个方法必须使用在同步代码块或同步方法中
• 2、wait()、notify()、notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则，或出现IllegalMonitorStateException异常
• 3、wait()、notify()、notifyAll()三个方法是定义在java.lang.Object类中

面试题：sleep()和wait的异同？
相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态
不同点：

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

JDK5.0新增线程创建方式

创建线程的方式三：实现Callable接口

步骤：

• 1.创建要实现Callable的实现类
• 2.实现call方法，将此线程需要执行的操作声明在call()中。并且可以返回一个值
• 3.创建Callable接口实现类的对象
• 4.将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
• 5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
• 6.获取Callable中call方法的返回值

import urrent.Callable;
import urrent.ExecutionException;
import urrent.FutureTask;/*** @author LawrenceLan* @create 2022--09--23--11:45*///1.创建要给实现Callable的实现类
class NumThread implements Callable{//2.实现call方法，将此线程需要执行的操作声明在call()中。并且可以返回一个值@Overridepublic Object call() throws Exception {int sum = 0;for (int i = 0; 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 = ();System.out.println("总和为:"+sum);} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}}
}

实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大体现在何处

• 1、call()可以有返回值
• 2、 call()可以抛出异常，被外面的操作捕获，获取异常的信息
• 3、Callable支持泛型

创建线程的方式四：使用线程池

背景：对于经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

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

好处：

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

import urrent.ExecutorService;
import urrent.Executors;
import urrent.ThreadPoolExecutor;/**** 创建线程的方式四：使用线程池** @author LawrenceLan* @create 2022--09--23--14:20*/class NumberThread implements Runnable{@Overridepublic void run() {for (int i = 0; i <= 100 ; i++) {if(i % 2 == 0){System.out.println(Thread.currentThread().getName()+":"+i);}}}
}class NumberThread1 implements Runnable{@Overridepublic 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 = wFixedThreadPool(10);ThreadPoolExecutor service1 = (ThreadPoolExecutor)service;// 向子类强制转型，才能调用子类的方法//设置线程池的属性
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象ute(new NumberThread());//适合使用于ute(new NumberThread1());//适合使用于Runnable//        service.submit();//适合使用于Callable//3.关闭线程池service.shutdown();}
}