Java多线程基础入门（已完结）

自由的羽毛  金牌会员 | 2022-9-16 17:16:00 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 934|帖子 934|积分 2802

线程简介

任务？
程序？
进程 Process？执行程序的一次执行过程，是一个动态的概念。是系统资源分配的单位
线程 Thread？一个进程中可以包含若干个线程，进程中至少有一个线程。线程是CPU调度和执行的单位
模拟多线程
线程实现（重点）

线程的创建

一、Thread类

1、使用方法

1.自定义线程类继承Thread类
2.重写run()方法，编写线程执行体
3.创建线程对象，调用start()方法启动线程
2、代码示例
  1. //创建线程方式一:继承Thread类,重写run()方法,调用start()开启线程
  2. public class TestThread1 extends Thread{
  3.     @Override
  4.     public void run() {
  5.         for (int i = 0; i < 10; i++) {
  6.             System.out.println("Thread----:"+i);
  7.         }
  8.     }
  10.     public static void main(String[] args) {
  11.         //main线程,主线程
  12.         //创建一个线程对象
  13.         TestThread1 testThread1=new TestThread1();
  14.         //调用方法开启线程
  15.         testThread1.start();
  16.         for (int i = 0; i < 10; i++) {
  17.             System.out.println("Main--------:"+i);
  18.         }
  19.     }
  20. }
复制代码
3、运行结果
  1. Main--------:0
  2. Main--------:1
  3. Thread----:0
  4. Thread----:1
  5. Main--------:2
  6. Thread----:2
  7. Main--------:3
  8. Main--------:4
  9. Main--------:5
  10. Main--------:6
  11. Thread----:3
  12. Main--------:7
  13. Main--------:8
  14. Main--------:9
  15. Thread----:4
  16. Thread----:5
  17. Thread----:6
  18. Thread----:7
  19. Thread----:8
  20. Thread----:9
复制代码
4、小结

线程开启不一定立即执行，而是由CPU选择调度执行
5、案例

下载图片
  1. //练习Thread,实现多线程同步下载图片
  2. public class TestThread2 extends Thread{
  3.     private String url;
  4.     private String name;
  5.     public TestThread2(String url, String name) {
  6.         this.url = url;
  7.         this.name = name;
  8.     }
  9.     @Override
  10.     public void run() {
  11.         WebDownloader webDownloader = new WebDownloader();
  12.         webDownloader.downloader(url,name);
  13.         System.out.println("下载了文件名为:"+name);
  14.     }
  15.     public static void main(String[] args) {
  16.         TestThread2 testThread2_1 = new TestThread2("https://img2.baidu.com/it/u=287632534,2172937882&fm=253&fmt=auto&app=138&f=JPEG?w=504&h=309","CSGO1.jpg");
  17.         TestThread2 testThread2_2 = new TestThread2("https://img0.baidu.com/it/u=3909898413,2777003333&fm=253&fmt=auto&app=120&f=JPEG?w=1422&h=800","CSGO2.jpg");
  18.         TestThread2 testThread2_3 = new TestThread2("https://img0.baidu.com/it/u=1130153521,1400899467&fm=253&fmt=auto&app=120&f=JPEG?w=1422&h=800","CSGO3.jpg");
  19.         testThread2_1.start();
  20.         testThread2_2.start();
  21.         testThread2_3.start();
  22.     }
  23. }
  24. class WebDownloader{
  25.     public void downloader(String url,String name) {
  26.         try {
  27.             FileUtils.copyURLToFile(new URL(url),new File(name));
  28.         } catch (IOException e) {
  29.             e.printStackTrace();
  30.             System.out.println("IO异常");
  31.         }
  32.     }
  33. }
复制代码
二、Runnable接口

1、使用方法

1.定义TestThread3类实现Runnable接口
2.实现run()方法，编写线程执行体
3.创建线程对象，传入testThread3对象，调用start()方法启动线程
代理方法
2、代码示例
  1. public class TestThread3 implements Runnable{
  2.     @Override
  3.     public void run() {
  4.         for (int i = 0; i < 10; i++) {
  5.             System.out.println("run:"+i);
  6.         }
  7.     }
  8.     public static void main(String[] args) {
  9.         TestThread3 testThread3=new TestThread3();
  10.         new Thread(testThread3).start();
  11.         for (int i = 0; i < 10; i++) {
  12.             System.out.println("main:"+i);
  13.         }
  14.     }
  15. }
复制代码
3、运行结果
  1. main:0
  2. run:0
  3. main:1
  4. run:1
  5. main:2
  6. run:2
  7. main:3
  8. run:3
  9. main:4
  10. run:4
  11. main:5
  12. run:5
  13. main:6
  14. run:6
  15. main:7
  16. run:7
  17. main:8
  18. run:8
  19. main:9
  20. run:9
复制代码
4、对比

继承Thread类

子类继承Thread类具备多线程能力
通过子类对象.start() 启动
不建议使用：避免OOP单继承局限性
实现Runnable接口

实现接口Runnable具有多线程能力
传入目标对象+Thread对象.start() 启动 代理模式 一份资源多个代理
  1. StartThread station=new StartThread();
  2. new Thread(station,"小明").start();
  3. new Thread(station,"小红").start();
  4. new Thread(station,"小刚").start();
复制代码
建议使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用
5、初识并发问题

购买车票场景问题

代码
  1. //多个线程同时操作同一个对象
  2. //买火车票的例子
  3. public class TestThread4 implements Runnable{
  4.     private int ticketNums=10;
  5.     @Override
  6.     public void run() {
  7.         while (true){
  8.             if (ticketNums<=0){
  9.                 break;
  10.             }
  11.             try {
  12.                 Thread.sleep(200);
  13.             } catch (InterruptedException e) {
  14.                 e.printStackTrace();
  15.             }
  16.             System.out.println(Thread.currentThread().getName()+":拿到了第"+ticketNums--+"张票");
  17.         }
  18.     }
  19.     public static void main(String[] args) {
  20.         TestThread4 testThread4=new TestThread4();
  21.         new Thread(testThread4,"1号线程").start();
  22.         new Thread(testThread4,"2号线程").start();
  23.         new Thread(testThread4,"3号线程").start();
  24.     }
  25. }
复制代码
5、线程优先级

Java提供一个线程调度器来监控监视程序中启动后进入到就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行

  • 线程的优先级用数字表示，范围从1~10
  • 通过getPriority().setPriority(int xxx)
  1. 1号线程:拿到了第10张票
  2. 3号线程:拿到了第9张票
  3. 2号线程:拿到了第8张票
  4. 2号线程:拿到了第6张票
  5. 3号线程:拿到了第7张票
  6. 1号线程:拿到了第6张票
  7. 1号线程:拿到了第5张票
  8. 2号线程:拿到了第5张票
  9. 3号线程:拿到了第4张票
  10. 3号线程:拿到了第3张票
  11. 2号线程:拿到了第1张票
  12. 1号线程:拿到了第2张票
复制代码
优先级高的不一定先跑
6、守护（daemon）线程


  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕
  • 例如：后台记录操作日志，监控内存，垃圾回收
  1. //模拟龟兔赛跑
  2. public class Race implements Runnable{
  3.     private static String winner;
  4.     @Override
  5.     public void run() {
  6.         for (int i = 0; i <=100; i++) {
  7.             if (Thread.currentThread().getName()=="兔子"&&i%10==0){
  8.                 try {
  9.                     Thread.sleep(2 );
  10.                 } catch (InterruptedException e) {
  11.                     e.printStackTrace();
  12.                 }
  13.             }
  14.             boolean flag=gameOver(i);
  15.             if(flag) break;
  16.             System.out.println(Thread.currentThread().getName()+"跑了："+i+"步");
  17.         }
  18.     }
  19.     private boolean gameOver(int steps){
  20.         if (winner!=null){
  21.             return true;
  22.         }else {
  23.             if (steps==100){
  24.                 winner=Thread.currentThread().getName();
  25.                 System.out.println("winner is"+winner);
  26.                 return true;
  27.             }
  28.         }
  29.         return false;
  30.     }
  31.     public static void main(String[] args) {
  32.         Race race=new Race();
  33.         new Thread(race,"兔子").start();
  34.         new Thread(race,"乌龟").start();
  35.     }
  36. }
复制代码
线程同步（重点）

并发：多个线程操作同一个资源
排队：多个线程访问同一个对象，并且某些线程还想修改这个对象，这时我们就需要线程同步，线程同步其实是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用
由于同一个进程的多个线程共享一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制 synchronized，当一个线程获得对象的排他锁，独占资源，其他线程必须等待，使用后释放锁即可，存在以下问题

  • 一个线程持有锁会导致其他所有需要此锁的线程被挂起
  • 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
  • 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题
购买车票场景问题2
  1. public class TestCallable implements Callable<Boolean> {
  2.     //实现call方法，需要抛出异常
  3.     @Override
  4.     public Boolean call() throws Exception {
  5.         WebDownloader webDownloader = new WebDownloader();
  6.         webDownloader.downloader(url,name);
  7.         System.out.println("下载了文件名为:"+name);
  8.         return true;
  9.     }
  11.     private String url;
  12.     private String name;
  14.     public TestCallable(String url, String name) {
  15.         this.url = url;
  16.         this.name = name;
  17.     }
  18.    
  19.     public static void main(String[] args) {
  20.         //创建目标对象
  21.         TestCallable testThread2_1 = new TestCallable("https://img2.baidu.com/it/u=287632534,2172937882&fm=253&fmt=auto&app=138&f=JPEG?w=504&h=309","CSGO11.jpg");
  22.         TestCallable testThread2_2 = new TestCallable("https://img0.baidu.com/it/u=3909898413,2777003333&fm=253&fmt=auto&app=120&f=JPEG?w=1422&h=800","CSGO21.jpg");
  23.         TestCallable testThread2_3 = new TestCallable("https://img0.baidu.com/it/u=1130153521,1400899467&fm=253&fmt=auto&app=120&f=JPEG?w=1422&h=800","CSGO31.jpg");
  24.         //创建执行服务
  25.         ExecutorService ser= Executors.newFixedThreadPool(3);
  26.         //提交执行
  27.         Future<Boolean> submit1 = ser.submit(testThread2_1);
  28.         Future<Boolean> submit2 = ser.submit(testThread2_2);
  29.         Future<Boolean> submit3 = ser.submit(testThread2_3);
  30.         //获取结果
  31.         try {
  32.             boolean rs1 = submit1.get();
  33.             boolean rs2 = submit2.get();
  34.             boolean rs3 = submit3.get();
  35.         } catch (InterruptedException e) {
  36.             e.printStackTrace();
  37.         } catch (ExecutionException e) {
  38.             e.printStackTrace();
  39.         }
  40.         //关闭服务
  41.         ser.shutdownNow();
  42.     }
  43. }
复制代码
synchronized与Lock的对比


  • Lock是显式锁（手动开启和关闭锁，try开启，finally关闭），synchronized是隐式锁，出了作用域自动释放
  • Lock只有代码块锁，synchronized有代码块锁和方法锁
  • 使用Lock锁，JVM将使用较少时间来调度线程，性能更好，并且具有更好的扩展性（提供更多子类）
  • 优先使用顺序：Lock->同步代码块（已经进入了方法体，分配了相应资源）->同步方法（在方法体外）
死锁

多个线程各自占有一些共享资源，并且互相等待其他线程占用的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情景。某一个同步块同时拥有“两个以上对象的锁”时，就可能发生“死锁问题”
  1. public class StacticProxy {
  2.     public static void main(String[] args) {
  3.         WeddingCompany weddingCompany=new WeddingCompany(new You());
  4.         weddingCompany.HappyMarry();
  5.     }
  8. }
  9. interface Marry{
  10.     void HappyMarry();
  11. }
  12. //真实角色
  13. class You implements Marry{
  14.     @Override
  15.     public void HappyMarry() {
  16.         System.out.println("marry");
  17.     }
  18. }
  19. //代理角色
  20. class WeddingCompany implements Marry{
  21.     private Marry target;
  23.     public WeddingCompany(Marry target) {
  24.         this.target = target;
  25.     }
  27.     @Override
  28.     public void HappyMarry() {
  29.         before();
  30.         this.target.HappyMarry();
  31.         after();
  32.     }
  34.     private void after() {
  35.         System.out.println("收尾款");
  36.     }
  38.     private void before() {
  39.         System.out.println("布置现场");
  40.     }
  41. }
复制代码
产生死锁的四个必要条件

1、互斥条件：一个资源每次只能被一个进程使用。
2、请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
3、不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
4、循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系
只要破坏其中任意一个或多个就可以避免死锁发生
线程通信问题

生产者消费者问题


  • 仓库中只能存放一件物品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费
  • 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止
  • 如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库再次放入产品为止
这是一个线程同步问题，生产者和消费者共享一个资源，并且生产者和消费者之间互相依赖，互为条件
关键方法wait()、notify()
wait：线程释放锁等待
notify：唤醒一个等待状态的线程
管程法
  1. public interface Runnable{
  2.         public abstract void run();
  3. }
复制代码
信号灯法

线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁，实现重复利用。类似生活中的公共交通工具
好处

1.提高响应速度（减少了创建新线程的时间）
2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
3.便于线程管理
​        （1）corePoolSize：核心池大小
​        （2）maximumPoolSize：最大线程数
​        （3）keepAliveTime：线程没有任务时最多保持多长时间后会终止
线程池相关API

ExecutorService和Executors
1.ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
​        （1）void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
​        （2）Future submit(Callable task)：执行任务，有返回值，一般用来执行Callable
​        （3）void shutdown()：关闭线程池
2.Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

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

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

自由的羽毛

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表