IT评测·应用市场-qidao123.com

标题: Java多线程并发编程 [打印本页]

---

作者: 饭宝    时间: 2022-9-16 17:15
标题: Java多线程并发编程
多线程并发

在多核CPU中，利用多线程并发编程，可以更加充分地利用每个核的资源

在Java中，一个应用程序对应着一个JVM实例（也有地方称为JVM进程），如果程序没有主动创建线程，则只会创建一个主线程。但这不代表JVM中只有一个线程，JVM实例在创建的时候，同时会创建很多其他的线程（比如垃圾收集器线程）。
线程创建

线程有三种创建方式：

• 继承Thread类 （可以说是 将任务和线程合并在一起）
  
• 实现Runnable接口 （可以说是 将任务和线程分开了）
  
• 实现Callable接口 (利用FutureTask执行任务)
  

对比：Runnable接口解决了Thread单继承的局限性。而Callable解决了Runnable无法抛异常给调用方的局限性。

1. class T extends Thread {
2.     @Override
3.     public void run() {
4.         println("我是继承Thread的任务");
5.     }
6. }
7. class R implements Runnable {  //解决了单继承问题
9.     @Override
10.     public void run() {
11.         println("我是实现Runnable的任务");
12.     }
13. }
14. class C implements Callable<String> {
16.     @Override
17.     public String call() throws Exception {  //可以抛异常
18.         println("我是实现Callable的任务");
19.         return "success";    //任务有返回值
20.     }
21. }

复制代码

线程启动

• 调用线程的start()方法，这里要注意，只有Thread方法可以调用start()，因此需要为其他类型的线程创建方式实例分配Thread实例。
  

1. // 启动继承Thread类的任务
2. Thread MyThread = new MyThread();
3. MyThread.start();
5. class MyThread extends Thread {
6.     @Override
7.     public void run() {
8.         System.out.println("hello myThread" + Thread.currentThread().getName());
9.     }
10. }
12. // 启动实现Runnable接口的任务
13. MyRunnable myRunnable = new MyRunnable();
14. Thread thread = new Thread(myRunnable);  //要给实现Runnable的实例分配新的对象
15. thread.start();
17. class MyRunnable implements Runnable{
18.     @Override
19.     public void run(){
20.         System.out.println("hello myRunnable" + Thread.currentThread().getName());
21.     }
22. }
24. // 启动实现了Callable接口的任务 结合FutureTask 可以获取线程执行的结果
25. FutureTask<String> target = new FutureTask<>(new C());  //C是实现了Callable接口的类
26. new Thread(target).start();
27. log.info(target.get());

复制代码

各线程类图


常用方法

方法说明setName("String");给线程设置名称getName();获取线程的名称Thread.currentThread();获取当前执行的线程对象Thread.sleep(ms);线程休眠(以ms为单位)线程同步

多个线程同时操作某个临界资源可能出现业务安全问题。采用互斥访问

加锁：把临界资源进行上锁，每次只允许一个线程进入访问完成后才解锁，允许其他进程进入
同步代码块

对代码块上锁

快捷键：CTRL+ALT+T
关于锁对象的选择
最好不要用任意唯一的锁对象，因为这会影响其他无关线程的执行。
规范上：建议使用临界资源作为锁对象
对于实例方法建议使用this作为锁对象
对于静态方法建议使用字节码(类名.class)作为锁对象

1. synchronized(同步锁对象) {  //synchronized(this) 只锁自己的临界资源
2.         //操作系统资源的代码(出现安全问题的核心代码)
3. }

复制代码

同步方法

对方法上锁

在方法定义时加上synchronized关键字即可
同步方法底层有隐式锁对象
如果方法是实例方法：同步方法默认使用this作为锁对象
如果方法是静态方法：同步方法默认使用类名.class作为锁对象

1. 修饰符 synchronized 返回值类型 方法名称(形参列表) {
2.         //操作系统资源的代码
3. }

复制代码

Lock锁

1. //创建锁
2. private final Lock lock = new ReentranLock();
4. lock.lock();    //加锁
5.         try {
6.         //锁住的内容
7.     } finally {
8.                 lock.unlock();  //解锁
9.     }

复制代码

线程通信

典型应用：生产者-消费者模型

实现方法：使用一个共享变量实现线程通信
方法名称功能锁.wait()让当前线程等待并释放所占锁，直到另一个线程调用notify()方法或notifyAll()方法锁.notify()唤醒正在等待的单个线程锁.notifyAll()唤醒正在等待的所有线程线程池

一个可以复用线程的技术，当请求过多时用于降低系统开销

ExecutorService代表线程池接口
如何得到线程池对象

方式一：使用ExecutorService的实现类ThreadPoolExecutor创建线程池对象



创建临时线程的条件：①核心线程全忙        ②任务队列满
拒绝任务的条件：临时线程和核心线程全忙
线程池处理Runnable任务的方法：

1. public class Communication {
2.     public static void main(String[] args) {
3.         //线程池创建
4.         ExecutorService pool = new ThreadPoolExecutor(3,5,2, TimeUnit.MINUTES, new ArrayBlockingQueue<>(5),new ThreadPoolExecutor.AbortPolicy());
5.         Runnable myRunnable = new myRunnable();
6.                 //线程池产生Runnable线程对象
7.         pool.execute(myRunnable);
8.         pool.execute(myRunnable);
9.         pool.execute(myRunnable);
10.         pool.execute(myRunnable);
11.         pool.execute(myRunnable);
12.         pool.execute(myRunnable);
13.         pool.execute(myRunnable);
14.         pool.execute(myRunnable);
15.         //开始创建临时线程
16.         pool.execute(myRunnable);
17.         pool.execute(myRunnable);
18.         //抛出异常
19.         pool.execute(myRunnable);
20.     }
21. }
23. /**
24. * 功能：用线程池实现Runnable对象
25. */
26. class myRunnable implements Runnable {
27.     @Override
28.     public void run() {
29.         for (int i = 0; i < 5; i++) {
30.             System.out.println(Thread.currentThread().getName() + "正在打印hello ==>" + i);
31.         }
32.         try {
33.             System.out.println(Thread.currentThread().getName() + "开始睡眠");
34.             Thread.sleep(1000000);
35.         } catch (Exception e) {
36.             e.printStackTrace();
37.         }
38.     }
39. }

复制代码

线程池处理Callable任务的方法

1. public class Communication {
2.     public static void main(String[] args) throws ExecutionException, InterruptedException {
3.         //线程池创建（不变）
4.         ExecutorService pool = new ThreadPoolExecutor(3,5,2,
5.                 TimeUnit.MINUTES, new ArrayBlockingQueue<>(5),new ThreadPoolExecutor.AbortPolicy());
6.                 //调用线程池的submit方法处理myCallable对象，并用Future Task的父类Future继承
7.         Future<String> f1 = pool.submit(new myCallable(100));
8.         Future<String> f2 = pool.submit(new myCallable(200));
9.         Future<String> f3 = pool.submit(new myCallable(300));
10.         Future<String> f4 = pool.submit(new myCallable(400));
11.         Future<String> f5 = pool.submit(new myCallable(500));
12.                 //调用get方法返回内容
13.         System.out.println(f1.get());
14.         System.out.println(f2.get());
15.         System.out.println(f3.get());
16.         System.out.println(f4.get());
17.         System.out.println(f5.get());
18.     }
19. }
21. /**
22. * 功能：用线程池实现Callable线程对象
23. */
24. class myCallable implements Callable<String> {
25.     private int n;
27.     public myCallable(int n) {
28.         this.n = n;
29.     }
30.     @Override
31.     public String call() throws Exception {
32.         int sum = 0;
33.         for (int i = 0; i < n; i++) {
34.             sum += i;
35.         }
36.         return Thread.currentThread().getName() + "计算的1-" + n + "结果为" + sum;
37.     }
38. }

复制代码

方式二：使用Executors（线程池的工具类）调用方法返回不同线程池对象【非重点】

Executors工具类底层是ThreadPoolExecutor，但在大型并发系统环境使用Executors可能出现系统风险

1.         ExecutorService pool = Executors.newFixedThreadPool(固定线程个数)
2.     //底层调用ThreadPoolExecutor，仅有核心线程

复制代码

定时器

一种控制任务延时调用，或者周期调用的技术

实现方式：：①Timer        ②ScheduledExecutorService定时器
Timer定时器

1. Timer timer = new Timer();
2. //schedule还有其他几种重载方式，见jdk
3. timer.schedule(new TimerTask() {
4.     @Override
5.     public void run() {
6.         //线程内容1
7.     }
8. },0,2000);
9.    
10. timer.schedule(new TimerTask() {
11.     @Override
12.     public void run() {
13.         //线程内容2
14.     }
15. },0,2000);

复制代码

Timer定时器存在的问题
1、Timer定时器是单线程，处理多个任务顺序执行，存在延时问题
2、因为是单线程，若Timer线程死掉，会影响后续任务执行
ScheduledExecutorService定时器

ScheduledExecutorService内部是一个线程池,一个任务不会干扰其他任务

ScheduledExecutorService在日常开发中更加常用

1. public static void main(String[] args) {
2.         //
3.     ScheduledExecutorService timer = new ScheduledThreadPoolExecutor(3);
5.     //scheduleAtFixedRate表示以固定频率定时
6.     timer.scheduleAtFixedRate(new Runnable() {
7.         @Override
8.         public void run() {
9.             System.out.println("定时1" + new Date());
10.         }
11.     },0,2,TimeUnit.SECONDS);
12.    
13.     timer.scheduleAtFixedRate(new Runnable() {
14.         @Override
15.         public void run() {
16.             System.out.println("定时2" + new Date());
17.         }
18.     },0,3,TimeUnit.SECONDS);
19. }

复制代码

线程生命周期




免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

---

欢迎光临 IT评测·应用市场-qidao123.com (https://dis.qidao123.com/)

Powered by Discuz! X3.4