首页 > 编程入门 文章详情

Java 基础 面试 多线程

编程入门 行业动态 更新时间:2024-10-19 03:32:52

Java 基础 面试 <a href=https://www.elefans.com/category/jswz/34/1767532.html style=多线程"/>

Java 基础 面试 多线程

1.多线程


1.1 线程（Thread）

线程时一个程序内部的一条执行流程，java的main方法就是由一条默认的主线程执行


1.2 多线程

    多线程是指从软硬件上实现的多条执行流程的技术（多条线程由CPU负责调度执行）

    许多平台都离不开多线程，因为多线程可以实现并发技术，只有通过多线程，才可能实现多人同时订票等功能，一个人就代表着一个线程

2. 创建多线程

Java是通过java.lang.Thread类的对象来代表线程的


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


2.1.1 创建步骤

  •     定义一个子类继承线程类java.lang.Thread，重写run( )方法，方法体交给另一个线程执行
  •     创建子类对象
  •     调用子类对象的start( )方法启动线程（通过start( )方法启动，cpu会自动分配线程执行run( )方法）
     
//1.子类MyThread继承Thread类
public class MyThread extends Thread{//2.重写run方法，run方法的方法体就是新的线程执行体@Overridepublic void run() {for (int i = 0; i < 5; i++) {System.out.println("MyThread执行" + i);}}
}

public class Test1 {//main方法默认就是由一个主线程负责执行public static void main(String[] args) {//3.创建一个子类对象即新的线程对象MyThread myThread = new MyThread();//4.调用start方法，启动新线程，执行run方法myThread.start();//5.主线程中，通过for循环执行主线程的执行体for (int i = 0; i < 5; i++) {System.out.println("main线程执行" + i);}}
}

2.1.2 优缺点

优点：编码简单

缺点：java是单继承，线程类已经继承了Thread类，就无法继承其他类，不利于功能的扩展

2.1.3 注意事项

  1. 启动线程必须调用start方法，不能调用run方法。直接调用run方法会被当成普通方法执行，cpu不会分配新的线程来执行run方法中的方法体，相当于还是单线程。
  2. 不能把主线程任务放在启动子线程之前，否则只有主线程任务执行完才会开启新的线程，没有意义，还是相当于单线程
public class Test2 {public static void main(String[] args) {MyThread myThread = new MyThread();//如果调用run方法，那么就不是启动新的线程，而是在主线程中调用run方法myThread.run();for (int i = 0; i < 5; i++) {System.out.println("main线程执行" + i);};}
}

result：
MyThread执行0
MyThread执行1
MyThread执行2
MyThread执行3
MyThread执行4
main线程执行0
main线程执行1
main线程执行2
main线程执行3
main线程执行4
由结果可以看出变成了单线程，只有主线程负责执行

public class Test2 {public static void main(String[] args) {MyThread myThread = new MyThread();for (int i = 0; i < 5; i++) {System.out.println("main线程执行" + i);};//主程序的执行体在线程开启之前，所以先执行主程序的执行体，相当于单线程myThread.start();}
}

main线程执行0
main线程执行1
main线程执行2
main线程执行3
main线程执行4
MyThread执行0
MyThread执行1
MyThread执行2
MyThread执行3
MyThread执行4

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

2.2.1 创建步骤

  1. 定义一个线程任务类实现Runnable接口，重写run( )方法
  2. 创建任务对象
  3. 将任务对象封装成Thread( )对象
  4. 调用Thread线程对象的start( )方法启动线程
//1.创建一个实现了Runnable接口的类
public class MyRunnable implements Runnable{//2.实现类去实现Runnable中的抽象方法run()@Overridepublic void run() {for (int i = 0; i < 5; i++) {System.out.println("子线程执行==》" + i);}}
}

public class Test1 {public static void main(String[] args) {//3.创建一个任务对象Runnable myRunnable = new MyRunnable();//4.将任务对象封装成一个线程对象并调用start方法new Thread(myRunnable).start();for (int i = 0; i < 5; i++) {System.out.println("main线程执行==>" + i);}}
}

result：
子线程执行==》0
main线程执行==>0
子线程执行==》1
main线程执行==>1
子线程执行==》2
main线程执行==>2
main线程执行==>3
main线程执行==>4
子线程执行==》3
子线程执行==》4

2.2.2 优缺点

优点：任务类只是实现接口，可以继续继承其他类、实现其他接口，扩展性强

缺点：需要多创建一个Runnable对象

2.2.3 使用匿名内部类改进代码

public class Test2 {public static void main(String[] args) {//使用匿名内部类的方式创建线程new Thread(new Runnable(){@Overridepublic void run() {for (int i = 0; i < 3; i++) {System.out.println("子线程1执行==>" + i);}}}).start();//使用lambda表达式创建线程new Thread(() ->{for (int i = 0; i < 3; i++) {System.out.println("子线程2执行==>" + i);}}).start();for (int i = 0; i < 3; i++) {System.out.println("main线程执行==>" + i);}}
}

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

2.3.1 实现步骤

  • 创建任务对象
  •     定义一个子类实现Callable接口，重写call方法，封装方法体和待返回数据
  •     将Callable类型的对象封装成FutherTask线程任务对象
  • 将FutherTask线程任务对象交给Thread对象封装
  • 调用Thread线程对象的start( )方法启动线程
  • 线程执行完毕后，通过FutherTask对象的get( )方法获取线程任务执行的结果
     

//1.创建一个实现Callable接口的实现类
public class MyCallable implements Callable<Double> {private int n;public MyCallable(int n) {this.n = n;}//2.重写call方法，call方法的方法体就是新的线程执行体@Overridepublic Double call() throws Exception {double sum = 0;for (int i = 1; i <= n; i++) {sum += i;}return sum;}
}

public class Test {public static void main(String[] args) throws Exception {//3.创建一个子类对象Callable<Double> myCallable = new MyCallable(100);//4.创建一个FutureTask对象，将myCallable对象作为构造参数传入FutureTask<Double> futureTask = new FutureTask<>(myCallable);//5.创建一个Thread对象，并将FutureTask对象作为构造参数传入new Thread(futureTask).start();//创建第二个线程FutureTask<Double> futureTask2 = new FutureTask<>(new MyCallable(200));new Thread(futureTask2).start();//6.通过FutureTask对象的get方法获取call方法的返回值//如果call方法没有执行完毕，get方法会阻塞等待Double v = futureTask.get();System.out.println(v);Double v2 = futureTask2.get();System.out.println(v2);}
}

2.3.2 优缺点

优点：

  • 线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强；
  • 可以在线程执行完毕后去获取线程执行的结果

缺点：编码比较复杂

3.线程常用方法：

方法说明
public void run( )线程中要执行的方法
public void start( )启动线程
public String getName( )获取当前线程的名称，线程名称默认是Thread-索引
public void setName( String name )修改线程的名称
public static Thread currentThread( )获取当前执行的线程对象
public static void sleep( long time )让当前执行的线程休眠多少毫秒，1000毫秒=1秒
public final void join( )让调用当前这个方法的线程先执行完再让其他线程执行

4. 线程安全问题

4.1 线程安全问题出现的原因

  • 存在多个线程在同时执行
  • 同时访问一个共享资源
  • 存在修改该共享资源

5. 线程同步（解决线程安全问题）

5.1 认识线程同步

解决线程安全问题的方案

5.1.1 线程同步的思想

让多个线程实现先后依次访问共享资源，这样就解决了安全问题

5.1.2 线程同步的常见方案

加锁：每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动解锁，然后其他线程才能再加锁进来

  • 同步代码块
  • 同步方法
  • Lock锁

5.2 三种加锁方式

5.2.1 同步代码块

作用：把访问共享资源的核心代码块上锁，以此保证线程安全

原理：每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行

注意事项：对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象），否则会出bug，因为对于不同的线程需要识别同步锁，同步锁一致才会让一个线程加锁，否则起不到加锁的作用。

锁对象的使用规范：使用共享资源作为锁对象

  1. 对于实例方法建议使用this关键字作为锁对象
//修改4.2.1的程序中Account类中的drawMoney( )方法，其余部分代码不变
//快捷键：ctrl+alt+tpublic void drawMoney(double drawMoney){String name = Thread.currentThread().getName();//同步代码块synchronized (this) {if (money >= drawMoney){System.out.println(name + "取钱成功，吐出钞票：" + drawMoney);money -= drawMoney;System.out.println(name + "取钱后的余额为：" + money);}else {System.out.println(name + "取钱失败，余额不足！");}}}
/*小明取钱成功，吐出钞票：100000.0小明取钱后的余额为：0.0小红取钱失败，余额不足！*/

2.对于静态方法建议使用字节码（类名.class)对象作为锁对象

//示例public static void test(){//同步代码块synchronized (Account.class) {}}

5.2.2 同步方法

作用：把访问共享资源的核心方法给上锁，以此保证线程安全

底层原理（与同步代码块一致，只是同步方法锁的范围更大）

  • 同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码
  • 如果方法是实例方法：同步方法默认用this作为锁对象
  • 如果方法是静态方法：同步方法默认用类名.clss作为锁对象
//修改4.2.1的程序中Account类中的drawMoney( )方法，其余部分代码不变
//使用synchronized修饰方法，同步方法public synchronized void drawMoney(double drawMoney){String name = Thread.currentThread().getName();//同步代码块if (money >= drawMoney){System.out.println(name + "取钱成功，吐出钞票：" + drawMoney);money -= drawMoney;System.out.println(name + "取钱后的余额为：" + money);}else {System.out.println(name + "取钱失败，余额不足！");}}
/*小明取钱成功，吐出钞票：100000.0小明取钱后的余额为：0.0小红取钱失败，余额不足！*/

5.2.3 Lock锁

  • Lock锁是JDK5开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大。
  • Lock是接口，不能直接实例化，可以采用它的实现类ReentrantLock来构建Lock锁对象。
//修改4.2.1的程序中Account类中的drawMoney( )方法，其余部分代码不变//创建锁对象private final Lock lock = new ReentrantLock();public void drawMoney(double drawMoney){String name = Thread.currentThread().getName();//使用try\cathc\finally代码块来确保锁一定会被释放,//否则一旦代码块中出现异常，锁就不会被释放try {//加锁lock.lock();if (money >= drawMoney){System.out.println(name + "取钱成功，吐出钞票：" + drawMoney);money -= drawMoney;System.out.println(name + "取钱后的余额为：" + money);}else {System.out.println(name + "取钱失败，余额不足！");}} catch (Exception e) {throw new RuntimeException(e);} finally {//释放锁lock.unlock();}}
/*小明取钱成功，吐出钞票：100000.0小明取钱后的余额为：0.0小红取钱失败，余额不足！*/

6. 线程通信（了解）

线程通信

当多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，以相互协调，并避免无效的资源争夺（线程通讯的前提是必须线程安全）

线程通信的常见模型（生产者与消费者模型）

  • 生产者线程负责生产数据

  • 消费者线程负责消费生产者生产的数据。

Object类提供的方法说明
void wait( )让当前线程等待并释放所占锁，直到另一个线程调用notify( )方法或notifyA11( )方法
void notify( )唤醒正在等待的单个线程
void notifyAll( )唤醒正在等待的所有线程
public class Desk {private List<String> list=new ArrayList<>();public synchronized void put(){try {String name = Thread.currentThread().getName();if(list.isEmpty()){list.add(name+" 做的包子");System.out.println(name+" 做的包子");Thread.sleep(1000);}this.notifyAll();this.wait();} catch (Exception e) {throw new RuntimeException(e);}}public synchronized void get(){try {String name = Thread.currentThread().getName();if(!list.isEmpty()){list.clear();System.out.println(name+" 吃了包子");Thread.sleep(100);}this.notifyAll();this.wait();} catch (Exception e) {throw new RuntimeException(e);}}}

public class Test {public static void main(String[] args) {Desk desk = new Desk(); //创建桌子对象//创建厨师线程new Thread(()->{while (true) {desk.put();}}, "厨师1").start();new Thread(()->{while (true) {desk.put();}}, "厨师2").start();new Thread(()->{while (true) {desk.put();}}, "厨师3").start();//创建吃货线程new Thread(()->{while (true) {desk.get();}}, "吃货1").start();new Thread(()->{while (true) {desk.get();}}, "吃货2").start();}
}

7. 线程池

7.1 认识线程池

7.1.1 什么是线程池

线程池就是一个可以复用线程的技术

7.1.2 不使用线程池的问题

用户每发起一个请求，后台就需要创建一个新线程来处理，下次新任务来了肯定又要创建新线程处理的，而创建新线程的开销是很大的，并且请求过多时，肯定会产生大量的线程出来，这样会严重影响系统的性能。

7.1.3 线程池的工作原理

  1. 如果线程池中有三个工作线程，则每个线程都会处理任务队列中的一个任务
  2. 当某个线程处理完一个任务后，该线程会继续处理任务队列中的其他任务，依次类推

7.2 创建线程池

JDK5.0起提供了代表线程池的接口：ExecutorService

7.1.1 创建线程池对象的方式一（推荐使用）

使用实现了ExecutorService接口的实现类ThreadPoolExecutor创建线程池对象

ThreadPoolExecutor构造器
//格式
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler)

//实例
public class Test{public static void main(String[] args) {// 创建线程池方式一/*线程池中有三个核心线程线程池中有五个最大线程线程池中有（5-3=2）个临时线程临时线程的存活时间为8秒线程池中有4个任务队列拒绝策略为：抛出异常并丢弃任务*/new ThreadPoolExecutor(3,5,8, TimeUnit.SECONDS,new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());}
}
  • 参数一：corePoolSize：指定线程池的核心线程的数量。（相当于饭店的固定服务员的数量）
  • 参数二：maximumPoolSize：指定线程池的最大线程数量。（相当于饭店的固定服务员和临时员工的数量）
  • 参数三：keepAliveTime：指定临时线程的存活时间。（相当于临时员工可以干多久）
  • 参数四：unit：指定临时线程存活的时间单位（秒、分、时、天）
  • 参数五：workQueue：指定线程池的任务队列。（相当于待招待的客人的数量）
  • 参数六：threadFactory：指定线程池的线程工厂。（相当于负责招聘服务员的hr）
  • 参数七：handler：指定线程池的任务拒绝策略（线程都在忙，任务队列也满了的时候，新任务来了该怎么处理）（相当于饭店的临时工和固定服务员仍然忙不过来时，应该如果对待新来的客人）
     
任务拒绝策略说明
ThreadPoolExecutor.AbortPolicy丢弃任务并抛出RejectedExecutionException异常。（默认策略）
ThreadPoolExecutor.DiscardPolicy丢弃任务，但是不抛出异常（不推荐）
ThreadPoolExecutor.DiscardOldestPolicy抛弃队列中等待最久的任务然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy由主线程负责调用任务的run( )方法从而绕过线程池直接执行
//创建Runnable任务类
public class MyRunnable implements Runnable{@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + "线程==>被调用了");try {//让线程睡眠一会，从而便于模拟并发环境Thread.sleep(Integer.MAX_VALUE);} catch (InterruptedException e) {throw new RuntimeException(e);}}
}

public class Test{public static void main(String[] args) {// 创建线程池ExecutorService pool = new ThreadPoolExecutor(3, 5, 8,TimeUnit.SECONDS, new ArrayBlockingQueue<>(4),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());// 创建Runnable任务实例对象Runnable target = new MyRunnable();//下面的三个任务被三个核心线程处理，不占用任务队列中的空间pool.execute(target);//该方法会在线程池中自动创建一个新线程自动处理任务，前提是线程池中有空闲线程pool.execute(target);pool.execute(target);//下面的四个任务进入任务队列等待处理pool.execute(target);pool.execute(target);pool.execute(target);pool.execute(target);//当任务队列满了并且核心线程全部被占用，会创建临时线程处理任务，//但是只能创建两个临时线程，因为最大线程数为5//下面的两个任务会被临时线程处理pool.execute(target);pool.execute(target);
//        下面的两个任务因为临时线程已经达到最大线程数，所以会根据拒绝策略进行处理pool.execute(target);}
}
/*
结果见下图此时由于三个核心线程被占用，四个任务也在任务队列中等待处理，两个临时线程也被占用，所以会根据拒绝策略进行任务处理*/

7.1.2 创建线程池对象的方式二（不推荐使用）

使用Executors(线程池的工具类)调用方法返回不同特点的线程池对象

Executors是一个线程池工具类，提供了许多静态方法用于返回不同特点的线程池对象

方法名称说明
public static ExecutorService newFixedThreadPool(int nThreads)创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代它。
public static ExecutorService newSingleThreadExecutor( )创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程。
public static ExecutorService newCachedThreadPool( )线程数量随着任务增加而增加，如果线程任务执行完并且空闲了6s则会被回收掉。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolsize)创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务。

 这些方法的底层，都是通过线程池的实现类ThreadPoolExecutor创建的线程池对象

缺点：大型并发系统环境中使用Executors?如果不注意可能会出现系统风险

  1. FixedThreadPool和SingleThreadPool

    允许的请求队列长度为Integer.MAX VALUE,可能会堆积大量的请求，从而导致OOM(内存溢出)。

  2. CachedThreadPool

    允许的创建线程数量为Integer.MAX VALUE,可能会创建大量的线程，从而导致OOM(内存溢出)。

使用线程池处理任务

ExecutorService的常用方法说明
void execute(Runnable command)执行Runnable任务
Future<T> submit( Callable<T> task)执行Cal1able任务，返回未来任务对象，用于获取线程返回的结果
void shutdown( )等全部任务执行完毕后，再关闭线程池！
List<Runnable> shutdownNow( )立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务

注意：一般不会关闭线程池，如果实在需要关闭，则使用void shutdown( )方法关闭

//1.创建一个实现Callable接口的实现类
public class MyCallable implements Callable<Double> {private int n;public MyCallable(int n) {this.n = n;}//2.重写call方法，call方法的方法体就是新的线程执行体@Overridepublic Double call() throws Exception {double sum = 0;for (int i = 1; i <= n; i++) {sum += i;}return sum;}
}

public class Test3 {public static void main(String[] args) throws Exception{//创建线程池ExecutorService pool = Executors.newFixedThreadPool(3);//创建Callable任务对象Callable<Double> c1 = new MyCallable(100);Callable<Double> c2 = new MyCallable(200);Callable<Double> c3 = new MyCallable(300);//执行任务并获取Future对象Future<Double> s1 = pool.submit(c1);Future<Double> s2 = pool.submit(c2);Future<Double> s3 = pool.submit(c3);//输出结果System.out.println(s1.get());System.out.println(s2.get());System.out.println(s3.get());}
}

8. 并发、并行、线程的生命周期

8.1 并发与并行

8.1.1 进程

  • 正在运行的程序（软件）就是一个独立的进程。
  • 线程是属于进程的，一个进程中可以同时运行很多个线程。
  • 进程中的多个线程其实并发和并行执行的。

8.1.2 并发

进程中的线程是由CPU负责调度执行的，但CPU能同时处理线程的数量有限，为了保证全部线程都能往前执行，CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。

8.1.3 并行

在同一个时刻上，同时有多个线程在被CPU调度执行。

8.2.1 Java线程的状态

  • Java定义了六种状态
  • 定义在Thread类的内部枚举类中

public enum State {NEW,RUNNABLE,BLOCKED,WAITING,TIMED_WAITING,TERMINATED;}
线程状态说明
NEW(新建)线程刚被创建，但是并未启动
Runnable(可运行)线程已经调用了start( ),等待CPU调度
Blocked(锁阻塞)线程在执行的时候未竞争到锁对象，则该线程进入Blocked状态
Waiting(无限等待)一个线程进入Waiting状态，另一个线程调用notify或者notifyAll方法才能够唤醒
Timed Waiting(计时等待)同waiting状态，有几个方法(sleep,wait)有超时参数，调用他们将进入Timed Waiting状态。
Teminated(被终止)因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

更多推荐

Java 基础 面试 多线程

本文发布于:2023-12-04 16:02:35，感谢您对本站的认可！
本文链接:https://www.elefans.com/category/jswz/34/1661465.html
版权声明:本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系，我们将在24小时内删除。
本文标签：多线程   基础   Java

发布评论

评论列表 （有 0 条评论）

最近发表

草根站长

>www.elefans.com

编程频道|电子爱好者 - 技术资讯及电子产品介绍！

热门文章

标签列表