• 多线程学习

    多线程的实现方式

    1. 继承Thread方法
    2. 实现Runable接口
    3. 实现Callable接口

    1.继承Thread方法 

    创建一个类继承Thread类，重写run方法

    通过多态创建一个子线程，子线程调用start方法

    1. //创建线程方式一：继承Thread类，重现run方法
    2. public class TestThread1 extends Thread{
    3.     @Override
    4.     public void run(){
    5.         for (int i=0;i<20;i++){
    6.             System.out.println(currentThread().getName()+"执行"+i);
    7.         }
    8.     }
    9.  
    10.     public static void main(String[] args) {
    11.         //创建一个子线程
    12.         Thread thread = new TestThread1();
    13.         //线程启动
    14.         thread.start();
    15.  
    16.  
    17.         for (int i=0;i<200;i++){
    18.             System.out.println(currentThread().getName()+"执行"+i);
    19.         }
    20.     }
    21. }

    2.实现Runnable接口

    创建一个类实现Runnable接口

    重写run方法

    创建runnable接口实现类对象

    创建Thread类对象，通过线程对象来开启我们的线程

    1. // 创建线程的方式2：实现runanable接口，重新写run方法，执行线程需要丢入runnable接口实现类，调用start方法
    2. public class TestThread3 implements Runnable{
    3.     @Override
    4.     public void run() {
    5.         //run方法线程体
    6.         for (int i=0 ; i<100; i++){
    7.             System.out.println(currentThread().getName()+":"+i);
    8.         }
    9.     }
    10.  
    11.     public static void main(String[] args) {
    12.         //创建runnable接口的实现类对象
    13.         TestThread3 testThread3 = new TestThread3();
    14.         //创建线程对象，通过线程对象来开启我们的线程，代理
    15.         Thread thread = new Thread(testThread3,"子线程1");
    16.         thread.start();
    17.         currentThread().setName("主线程");
    18.         for (int i = 0; i < 100; i++) {
    19.             System.out.println(currentThread().getName()+":"+i);
    20.         }
    21.     }
    22. }

    小结

    • 继承Thread类
      • 子类继承Thread类具有多线程能力
      • 启动线程：子类对象.start()
      • 不建议使用：避免OOP单继承局限性
    • 实现Runnable接口
      • 实现接口Runnable具有多线程能力
      • 启动线程：传入目标对象+Thread对象.start()
      • 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

     并发线程遇到数据紊乱问题

    1. //多个线程同时操作一个对象
    2. //买火车票的例子
    3.  
    4. //发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱
    5. public class TestThread4 implements Runnable{
    6.  
    7.     //票数
    8.     private int sum = 20;
    9.  
    10.     @Override
    11.     public void run() {
    12.         while (true){
    13.             if (sum<=0){
    14.                 break;
    15.             }
    16.             try {
    17.                 Thread.sleep(100);
    18.             } catch (InterruptedException e) {
    19.                 throw new RuntimeException(e);
    20.             }
    21.             System.out.println(Thread.currentThread().getName()+"拿到了第"+sum--+"票");
    22.         }
    23.     }
    24.  
    25.     public static void main(String[] args) {
    26.         TestThread4 testThread4 = new TestThread4();
    27.         new Thread(testThread4,"线程1").start();
    28.         new Thread(testThread4,"线程2").start();
    29.  
    30.     }
    31. }
    32.  
    33.  
    34. 线程1拿到了第19票
    35. 线程2拿到了第20票
    36. 线程1拿到了第17票
    37. 线程2拿到了第18票
    38. 线程1拿到了第16票
    39. 线程2拿到了第15票
    40. 线程2拿到了第14票
    41. 线程1拿到了第13票
    42. 线程1拿到了第12票
    43. 线程2拿到了第11票
    44. 线程1拿到了第9票
    45. 线程2拿到了第10票
    46. 线程1拿到了第8票
    47. 线程2拿到了第8票
    48. 线程2拿到了第7票
    49. 线程1拿到了第6票
    50. 线程2拿到了第4票
    51. 线程1拿到了第5票
    52. 线程1拿到了第3票
    53. 线程2拿到了第2票
    54. 线程1拿到了第1票
    55. 线程2拿到了第0票

    3.实现CallAble接口 

    1. 创建执行服务：创建线程池
    2. 提交执行
    3. 获取结果
    4. 关闭服务

    重写call方法，创建线程池，提交线程子类

    1. /**
    2.  * 可以拥有返回值
    3.  * 可以抛出异常
    4.  */
    5. public class TestCallable implements Callable {
    6.  
    7.     @Override
    8.     public Boolean call() throws Exception {
    9.         String inputurl = "mvnw.cmd";
    10.         String outputurl = Thread.currentThread().getName()+".cmd";
    11.         InputStream inputStream = new FileInputStream(inputurl);
    12.         OutputStream outputStream = new FileOutputStream(outputurl);
    13.         byte[] bytes = new byte[1024];
    14.         while (inputStream.read(bytes)!=-1){
    15.             outputStream.write(bytes);
    16.         }
    17.         return Boolean.TRUE;
    18.     }
    19.  
    20.     public static void main(String[] args) throws Exception {
    21.         TestCallable t1 =new TestCallable();
    22.         TestCallable t2 =new TestCallable();
    23.         TestCallable t3 =new TestCallable();
    24.  
    25.         //创建执行服务：创建线程池
    26.         ExecutorService ser = Executors.newFixedThreadPool(3);
    27.  
    28.         //提交执行
    29.         Future submit1 = ser.submit(t1);
    30.         Future submit2 = ser.submit(t2);
    31.         Future submit3 = ser.submit(t3);
    32.  
    33.         //获取结果
    34.         Boolean aBoolean1 = submit1.get();
    35.         Boolean aBoolean2 = submit2.get();
    36.         Boolean aBoolean3 = submit3.get();
    37.  
    38.         //关闭服务
    39.         ser.shutdown();
    40.     }
    41. }

    线程的状态

    • 创建状态
    • 就绪状态
    • 运行状态
    • 阻塞状态
    • 死亡状态

    方法说明
    setPriority(int newPriority)更改线程优先级
    static void sleep(long millis)在指定的毫秒数内让当前正在执行的线程休眠
    void join()等待该线程终止
    static void yield()暂停当前正在执行的线程对象，并执行其他线程
    void interrrupt()中断线程（不用）
    boolean isAlive测试线程是否处于活动状态

    线程休眠

    • sleep(时间)指定当前线程阻塞的毫秒数；
    • sleep存在异常InterruptedException；
    • sleep时间达到后线程进入就绪状态；
    • sleep可以模拟网络延时，倒计时等；
    • 每一个对象都有一个锁，sleep不会释放锁；

    线程礼让

    yield不一定成功

    1. /**
    2.  * 测试yield
    3.  * 礼让不一定成功
    4.  */
    5. public class TestYield{
    6.     public static void main(String[] args) {
    7.         MyYield myYield = new MyYield();
    8.         Thread t1 = new Thread(myYield,"a线程");
    9.         Thread t2 = new Thread(myYield,"b线程");
    10.         t1.start();
    11.         t2.start();
    12.     }
    13. }
    14.  
    15. class MyYield implements Runnable{
    16.  
    17.     @Override
    18.     public void run() {
    19.         System.out.println(Thread.currentThread().getName()+"开始执行");
    20.         Thread.yield();
    21.         System.out.println(Thread.currentThread().getName()+"执行结束");
    22.     }
    23. }

    线程优先级

    • Java提供一个线程调度器来监控程序中启动进入就绪状态的所有线程，线程调度器按照优先级决定的那个应该调度哪个线程来执行
    • 线程的优先级用数字表示，范围从1~10
      • Thread.MIN_PRIORITY=1;
      • Thread.Max_PRIORITY=10;
      • Thread.NORM_PRIORITY=5;
    • 使用一下方式改变或获取优先级
      • getPriority.setPRiority(int xxx);
    1. public class TestPriority {
    2.  
    3.     public static void main(String[] args) {
    4.         Mypriority mypriority = new Mypriority();
    5.         Thread t1 = new Thread(mypriority, "t1");
    6.         Thread t2 = new Thread(mypriority, "t2");
    7.         Thread t3 = new Thread(mypriority, "t3");
    8.         t2.setPriority(4);
    9.         t3.setPriority(Thread.MAX_PRIORITY);
    10.         t1.start();
    11.         t2.start();
    12.         t3.start();
    13.         System.out.println(Thread.currentThread().getName()+Thread.currentThread().getPriority());
    14.     }
    15. }
    16.  
    17.  
    18. class Mypriority implements Runnable{
    19.  
    20.     @Override
    21.     public void run() {
    22.         System.out.println(Thread.currentThread().getName()+Thread.currentThread().getPriority());
    23.     }
    24. }

    守护线程

    • 线程分为用户线程和守护线程
    • 虚拟机必去确保用户线程执行完毕
    • 虚拟机不用等待守护线程执行完毕，守护线程等待最后一个用户线程结束结束
    • 守护线程:操作日志，监控内存，垃圾回收等待。
    1. //测试守护线程
    2.  
    3. public class TestDaemon {
    4.     public static void main(String[] args) {
    5.         Thread human = new Thread(new Human());
    6.         Thread god = new Thread(new God());
    7.         Thread human2 = new Thread(new Human2());
    8.         god.setDaemon(true);//开启守护线程
    9.         human.start();
    10.         god.start();
    11.         human2.start();
    12.     }
    13. }
    14.  
    15. class Human implements Runnable{
    16.  
    17.     @Override
    18.     public void run() {
    19.         for (int i = 0; i < 10; i++) {
    20.             System.out.println("用户进程"+i);
    21.         }
    22.     }
    23. }
    24.  
    25. class God implements Runnable{
    26.  
    27.     @Override
    28.     public void run() {
    29.         while (true){
    30.             try {
    31.                 Thread.sleep(100);
    32.             } catch (InterruptedException e) {
    33.                 throw new RuntimeException(e);
    34.             }
    35.             System.out.println("守护进程");
    36.         }
    37.     }
    38. }
    39.  
    40. class Human2 implements Runnable{
    41.  
    42.     @Override
    43.     public void run() {
    44.         for (int i = 0; i < 10; i++) {
    45.             try {
    46.                 Thread.sleep(100);
    47.             } catch (InterruptedException e) {
    48.                 throw new RuntimeException(e);
    49.             }
    50.             System.out.println("用户线程2"+i);
    51.         }
    52.     }
    53. }

    线程的同步机制

    由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被i访问时的正确性，在访问时加入锁机制sychronized，当一个线程获得对象的排他锁，独占资源，其他线程必须的等待，

    使用后释放锁即可，存在下列问题：

    • 一个线程持有锁会导致其他所有拥有此锁的线程挂起：
    • 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；
    • 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题。

    同步方法 

    • 由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized放啊和synchronized块
    • 同步方法：public synchronized void method(int args){}
    • synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，知道该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行
    • 缺陷：若将一个大的方法申明为synchronized将会影响效率

    同步块 

    • 同步块：synchronized（OBJ）{}
    • Obj称之为同步监视器
      • Obj可以是任何对象，到那时推荐使用共享资源作为同步监视器
      • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class【反射】
    • 同步监视器的执行过程
      • 第一个线程访问，锁定同步监视器

    死锁

    死锁：多个线程互相抱着对方需要的资源，然后形成僵持

    产生死锁的四个必要条件：

    • 互斥条件：一个资源每次只能被一个进程使用。
    • 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
    • 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。
    • 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。
    1. package cn.cslg.kuangshen.lock;
    2.  
    3. public class DeadLock extends Thread{
    4.  
    5.     public static void main(String[] args) {
    6.         Thread t1 = new DeadLock(0);
    7.         Thread t2 = new DeadLock(2);
    8.         t1.setName("t1");
    9.         t2.setName("t2");
    10.         t1.start();
    11.         t2.start();
    12.     }
    13.     private int choose = 0;
    14.     private String lipstick ="a";
    15.     private String mirror ="b";
    16.     @Override
    17.     public void run() {
    18.         if (choose == 0){
    19.             synchronized (lipstick){
    20.                 System.out.println(Thread.currentThread().getName()+"lipstick");
    21.                 try {
    22.                     Thread.sleep(100);
    23.                 } catch (InterruptedException e) {
    24.                     throw new RuntimeException(e);
    25.                 }
    26.                 synchronized (mirror){
    27.                     System.out.println(Thread.currentThread().getName()+"mirror");
    28.                 }
    29.             }
    30.         }else {
    31.             synchronized (mirror){
    32.                 System.out.println(Thread.currentThread().getName()+"lipstick");
    33.                 synchronized (lipstick){
    34.                     System.out.println(Thread.currentThread().getName()+"mirror");
    35.                 }
    36.             }
    37.         }
    38.  
    39.     }
    40.  
    41.     public DeadLock(int choose){
    42.         this.choose = choose;
    43.     }
    44. }

    Lock（锁） 

    1. package cn.cslg.kuangshen.lock;
    2.  
    3. import java.util.concurrent.locks.ReentrantLock;
    4.  
    5. //测试Lock锁
    6. public class TestLock {
    7.     public static void main(String[] args) {
    8.         TestLock2 testLock2 = new TestLock2();
    9.         Thread t1 = new Thread(testLock2,"t1");
    10.         Thread t2 = new Thread(testLock2,"t2");
    11.         t1.start();
    12.         t2.start();
    13.     }
    14. }
    15.  
    16. class TestLock2 implements Runnable{
    17.     private int ticketNums =10;
    18.     //定义lock锁
    19.     private ReentrantLock lock = new ReentrantLock();
    20.     @Override
    21.     public void run() {
    22.         try {
    23.             //加锁
    24.             lock.lock();
    25.             while (ticketNums>0){
    26.                 try {
    27.                     Thread.sleep(100);
    28.                 } catch (InterruptedException e) {
    29.                     throw new RuntimeException(e);
    30.                 }
    31.                 System.out.println(Thread.currentThread().getName()+ticketNums--);
    32.             }
    33.         } catch (Exception e) {
    34.             throw new RuntimeException(e);
    35.         }finally {
    36.             //解锁
    37.             lock.unlock();
    38.         }
    39.  
    40.     }
    41. }

    生产者消费者问题 略过

    使用线程池

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

    思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

    好处：

    • 提高响应速度（减少了创建新线程的时间）
    • 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
    • 便于线程管理
      • corePoolSize:核心池大小
      • maxinmumPoolSize：最大线程数
      • keepAliveTime:线程没有任务时最多保持多长事件后会终止
    1. //测试线程池
    2. public class TestPool {
    3.  
    4.     public static void main(String[] args) {
    5.         //创建服务，创建线程池
    6.         ExecutorService executorService = Executors.newFixedThreadPool(2);
    7.         //执行
    8.         executorService.submit(new TestThread());
    9.         executorService.submit(new TestThread());
    10.         executorService.submit(new TestThread());
    11.         //关闭连接
    12.         executorService.shutdown();
    13.     }
    14. }
    15.  
    16. class TestThread implements Runnable{
    17.  
    18.     @Override
    19.     public void run() {
    20.         System.out.println(Thread.currentThread().getName());
    21.     }
    22. }

  • 相关阅读:
    指针类型的意义
    Vuex的基本使用
    48页数字政府智慧政务一网通办解决方案
    怎样将excel的科学计数法设置为指数形式？
    Vue使用ElementUi进行模糊搜索
    Java 可变参数及集合工具类（Collections）
    go开发之个微机器人的二次开发
    一种tcp传输json包时出现包不完整、粘包的解决方案
    Linux下的web服务器搭建
    cpp基础学习笔记02
  • 原文地址：https://blog.csdn.net/weixin_46543456/article/details/127692207