devbox
一键难忘520
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java多线程并发编程_java多线程并发代码

作者：一键难忘520 | 2024-08-04 03:59:47

赞

踩

java多线程并发代码

多线程并发

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

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

线程创建

线程有三种创建方式：

Thread
Runnable
Callable

对比：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 {  //解决了单继承问题
  8.  
  9.     @Override
  10.     public void run() {
  11.         println("我是实现Runnable的任务");
  12.     }
  13. }
  14. class C implements Callable<String> {
  15.  
  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();
    4.  
    5. class MyThread extends Thread {
    6.     @Override
    7.     public void run() {
    8.         System.out.println("hello myThread" + Thread.currentThread().getName());
    9.     }
    10. }
    11.  
    12. // 启动实现Runnable接口的任务
    13. MyRunnable myRunnable = new MyRunnable();
    14. Thread thread = new Thread(myRunnable);  //要给实现Runnable的实例分配新的对象
    15. thread.start();
    16.  
    17. class MyRunnable implements Runnable{
    18.     @Override
    19.     public void run(){
    20.         System.out.println("hello myRunnable" + Thread.currentThread().getName());
    21.     }
    22. }
    23.  
    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();
    3.  
    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. }
    22.  
    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. }
    20.  
    21. /**
    22.  * 功能：用线程池实现Callable线程对象
    23.  */
    24. class myCallable implements Callable<String> {
    25.     private int n;
    26.  
    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);
  4.  
  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. }

线程生命周期

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/一键难忘520/article/detail/926130
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号