多线程详解

多线程详解

一、线程的简介

任务、进程、线程、多线程

多任务

• 比如一边吃饭，一边玩手机；一边上厕所一边玩手机；现实生活中太多这样同时做多件事情的例子了，看起来是多个任务都在做，其实本质上我们的大脑在同一时间依旧只做了一件事情。

多线程

• 原来是一条路，慢慢遗忘车太多，道路堵塞，效率极低。为了提高使用效率，能够充分利用道路，于是加了多个车道，从此，妈妈再也不用担心道路堵塞了。
  

进程(Process)、线程(Thread)

在操作系统中运行的程序就是进程，比如你的QQ，游戏，腾讯视频等。。。

在一个应用程序里可以同时做很多事情就线程，一个进程里有多个线程。比如播放器这个应用，它可以播放声音的同时可以有图片显示，还有字幕显示，一个线程控制一个功能。

核心概念

• 线程就是独立的执行路径；

• 在程序运行时，即使没有自己创建线程，后天也会有多个线程，如主线程，gc线程；

• main（）称为主线程，为系统的入口，用于执行整个程序；

• 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的。

• 对同一份资源操作时，如CPU调度时间，并发控制开销。

• 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致.
  

线程的创建

线程的创建方式 1.继承Thread类

注意：很多多线程是模拟出来的，真正的多线程是指由多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，CPU只能执行一个代码，因为切换的块，所以就有同时执行的错觉。

package com.mjh.thread;
/**
 * 注意：线程开启不是立即执行，有CPU调度执行
 *     
 */
public class TestThread1 extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i <200 ; i++) {
            System.out.println("我在看电视----"+i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程
        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();

        //调用start（）方法开启线程
        testThread1.start();

        for (int i = 0; i < 500; i++) {
            System.out.println("我在上厕所-----"+i);
        }

    }
}

虽然是同时执行的，但是每一次CPU值执行一个（因为是单核）

2. 实现Runnable接口

package com.mjh.thread;

/**
 * 创建线程方法2:实现runnable接口，重写run方法，
 * 执行线程需要丢入runnable接口实现类，调用start（）
 */
public class TestThread3 implements Runnable{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i <200 ; i++) {
            System.out.println("我在看电视----"+i);
        }
    }

    public static void main(String[] args) {
      //创建runnable接口的实现类对象
        TestThread3 testThread3 = new TestThread3();

      //创建线程对象，通过线程对象来开启我们的线程，代理
       /* Thread thread = new Thread(testThread3);
        thread.start();
        */

       new Thread(testThread3).start();

        for (int i = 0; i < 500; i++) {
            System.out.println("我在上厕所-----"+i);
        }

    }
}

3.实现Callable方法

与Runnable相比，Callable功能更加强大些

• 相比于run方法，可以有返回值

• 方法可以抛出异常

• 支持泛型的返回值

• 需要借助FunturnTask类，比如获取返回值结果

  package com.mjh.thread;
  
  import org.apache.commons.io.FileUtils;
  
  import java.io.File;
  import java.io.IOException;
  import java.net.URL;
  import java.util.concurrent.*;
  
  public class TestCallable6 implements Callable<Boolean> {
  
      private String url;//网络图片名
      private String name;//保存的文件名
  
      public TestCallable6(String url, String name){
          this.url=url;
          this.name=name;
      }
  
      @Override
      public Boolean call() {
          WebDownloader webDownloader = new WebDownloader();
          webDownloader.downloader(url,name);
          System.out.println("下载了文件名为："+name);
          return true;
      }
  
      public static void main(String[] args) throws ExecutionException, InterruptedException {
          TestCallable6 t1 = new TestCallable6("http://inews.gtimg.com/newsapp_match/0/8677586534/0","1.jpg");
          TestCallable6 t2 = new TestCallable6("http://pic.962.net/up/2017-12/20171218154534653750.jpg","2.jpg");
  
        //创建执行服务
          ExecutorService ser = Executors.newFixedThreadPool(2);
  
        //提交执行
          Future<Boolean> r1 = ser.submit(t1);
          Future<Boolean> r2 = ser.submit(t2);
  
          //提交结果
          Boolean rs1 = r1.get();
          Boolean rs2 = r1.get();
  
          //关闭服务
          ser.shutdownNow();
  
      }
  
      //下载器
      class WebDownloader{
  
          public void downloader(String url,String name) {
              try {
                  FileUtils.copyURLToFile(new URL(url),new File(name));
              } catch (IOException e) {
                  e.printStackTrace();
                  System.out.println("IO异常，download方法出现问题！");
              }
          }
      }
  }
  

4.使用线程池

• 背景：经常创建和销毁，使用量特别大资源，不如并发情况下的线程，对性能影响很大
• 思路：提前创建好多个线程，放入线程池中，使用是直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具
• 好处：
  • ​ 提高响应速度（减少创建子新线程的时间）
  • ​ 降低资源消耗（重复利用线程池线程，不需要每次都创建）
  • ​ 便于线程管理

小结：

继承Thread

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

实现Runnable接口

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

初始并发问题

package com.mjh.thread;

/**
 * 多个线程同时操作同一个对象
 * 买火车票的例子
 */
public class TestThread4 implements Runnable {

    //票数
    private int  ticketNums=10;

    @Override
    public void run() {
        while(true){
            if(ticketNums<=0){break;}
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"--->拿到第"+ticketNums--+"票");
        }

    }

//一个资源多个线程拿
    public static void main(String[] args) {
        TestThread4 testThread4 = new TestThread4();
        new Thread(testThread4,"小明").start();
        new Thread(testThread4,"小红").start();
        new Thread(testThread4,"黄牛党").start();
    }
}

并发问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱。（解决办法：同步）

案例：龟兔赛跑

package com.mjh.thread;

public class TestThread5 implements Runnable {
    private  static String winner;
    @Override
    public void run() {
        for (int i = 0; i <=100 ; i++) {
            //模拟兔子休息,每10米休息一下
            if(Thread.currentThread().getName().equals("兔子")&& i%10==0){
                try {
                    Thread.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //判断比赛是否结束
            boolean flag = gameOver(i);
            if (flag){break;}

            System.out.println(Thread.currentThread().getName()+"---->跑了"+i+"米");
        }
    }

    //判断是否比赛结束
    private boolean gameOver(int rice){
        if(winner!=null){return  true; }
        {
            if (rice >= 100) {
                winner = Thread.currentThread().getName();
                System.out.println("winner is " + winner);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        TestThread5 race = new TestThread5();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }

}

线程状态

线程休眠(sleep)

• sleep（时间）指定当前线程阻塞的毫秒数（1000毫秒=1秒）

• sleep存在异常InterruptedException

• sleep时间达到后线程进入就绪状态

• sleep可以模拟网络延迟时，倒计时等

• 每一个对象都有一个锁，sleep不会释放锁

  举例：计时

  package com.mjh.thread;
  
  import java.text.SimpleDateFormat;
  import java.util.Date;
  
  public class TestSleep{
  
      public static void main(String[] args) {
          try {
              tenDown();
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
      }
  
      //模拟倒计时
      public static void tenDown() throws InterruptedException {
          int num=10;
          while(true){
              Thread.sleep(1000);
              System.out.println(num--);
              if(num<=0){
                  break;
              }
          }
      }
  }
  

package com.mjh.thread;

import java.text.SimpleDateFormat;
import java.util.Date;

public class TestSleep2{

    public static void main(String[] args)  {
     //打印当前系统时间
        Date startTime=new Date(System.currentTimeMillis());//获取当前系统时间
        try {
            while(true){
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime=new Date(System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

线程礼让（yield）

• 礼让线程，让当前正在执行的线程暂停，但不阻塞
• 将线程从运行状态转为就绪状态
• 让CPU重新调度，礼让不一定成功，看CPU心情

线程强制执行(join)

• join合并线程，待此线程执行完成之后，再执行其他线程，其他线程阻塞
• 可以想象成插队

线程状态观测

（查看JDK帮助文档）

线程优先级

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

• 线程的优先级用数字来表示，范围从1-10

  • Thread.MIN_PRIORITY=1;
  • Thread.MAX_PRIORITY=10;
  • Thread.MORM_PRIORITY=5;

• 优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这都是看CPU的调度

• 使用以下方式获得或者改变优先级

  • getPriority()，setPriority(int xxx)

• 优先级的设定建议在start调度之前

守护(Daemon)线程

• 线程分为用户线程和守护线程

• 虚拟机必须确保用户线程执行完毕

• 虚拟机不用等待守护线程执行完毕

  package com.mjh.thread;
  
  public class TestDemon {
      public static void main(String[] args) {
          God god = new God();
          You you = new You();
  
          Thread thread = new Thread(god);
          thread.setDaemon(true);//默认是false表示用户线程，正常的线程都是用户线程
          thread.start();//上帝 守护线程启动
  
          new Thread(you).start();//你 用户线程启动
  
      }
  
      //上帝
      static class God implements Runnable{
  
          @Override
          public void run() {
              while (true){
                  System.out.println("上帝保佑着你");
              }
          }
      }
  
      //你
      static class You implements Runnable{
  
          @Override
          public void run() {
              for (int i = 0; i <36500 ; i++) {
                  System.out.println("你一生都开心的活着");
              }
              System.out.println("-=======goodbye!world!");
          }
      }
  }
  

解决线程安全问题的方式

1.同步方法

2.同步代码块

3.Lock（锁）

线程同步机制

多个线程操作同一个资源

并发

同一个对象被多个线程同时操作

线程同步（synchronized）

• 现实生活中，我们会遇到“同一个资源，多个人都想使用”的问题，比如，食堂排队打饭，每个人都想吃饭，最天然的解决办法就是：排队，一个一个来（队列）

• 处理多线程问题时，多个线程访问同一个对象（并发），并且某些线程还想修改这个对象。

  这时候我们就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程在使用

• 由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入了锁机制（synchronized）,当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可（就像你上厕所要把门锁上，外面的人要等你打开门才能进去）。存在以下问题：

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

同步方法

public synchronized void method(int srgs){}

• synchronized方法控制对“对象”的访问，每个对象对象一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行（例如上厕所）

• 缺陷：若将一个大的方法申明为synchronized将会影响效率

同步代码块

synchronized(obj){}

• Obj称为同步监视器

  • obj可以是任何对象，但是推荐使用共享资源作为同步监视器

  • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this,就是这个对象本身，或者class

  

sleep()和wait()的区别？

1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态

2.不同点：1）两个方法声明的位置不同，Thread类中声明sleep（）， Object类中声明wait（）

​ 2）调用的要求不同：sleep（）可以在任意需要的场景下调用，wait（）必须使用在同步代码块或者同步方法中

​ 3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或者同步方法中，sleep（）不会释放锁，wait（）会释放锁。

死锁

• 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁

• 出现死锁之后，不会出现异常，不会出现提示，知识所有的线程都持于阻塞状态，无法继续

  

解决方法

• 专门的算法、原则

• 尽量减少同步资源的定义

• 尽量避免嵌套同步

  

Lock(锁)

• java提供了更强大的线程同步机制——通过显示定义同步锁对象实现同步。同步锁使用Lock对象充当

• java.util.concurrent.locks.Lock接口时控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问资源之前应先获得Lock对象

• ReentrantLock类（可重入锁）实现了Lock，它拥有synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock,可显示加锁，释放锁。

synchronized 和Lock的对比

• Lock是显示锁（手动开启和关闭锁，别忘记关闭锁）synchronized是隐式锁，出了作用域自动释放

• Lock只有代码块锁，synchronized有代码块锁和方法锁

• 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且有较好的扩展性（提供更多的类）

• 优先使用顺序：

  Lock>同步代码块（已经进入了方法体，分配了相应资源）>同步方法（在方法体之外）