Java线程的三种实现方法

Java多线程详解

线程简介

多任务，多线程

多任务情况中，虽然可以完成，但是实际上，多任务的完成是由一个一个小任务的完成来实现的，也就是说在执行多任务时，不是同时执行多个任务，而是一个时间段内只完成一个任务。

多线程情况中，则是依赖于CPU的功能，瞬间同时执行多个线程，或者说主线程和子线程并行交替执行。

程序 进程 线程

1. 程序就是指令和数据的有序集合，本身没有任何运行的含义，是一个静态的概念

2. 进程是执行程序的一次执行过程，是一个动态的概念

3. 线程包含在进程中，一个进程可以由多个线程，一个进程至少有一个线程（主线程main），线程是CPU调度和执行的单位

线程的三种创建方式

• 通过声明Thread类的子类，重写run类的方法Thread创建

  //继承Thread类，重写run方法中的代码块
  public class Testing01 extends Thread{
      public void run(){
          //run方法代码块
          for (int i = 0; i < 10; i++) {
              System.out.println("run方法运行次数" + i);
          }
      }
      public static void main(String[] args){
          //开启线程的方法：1.创建对象 2.调用start方法
          Testing01 t1 = new Testing01();
          t1.start();
          //主线程
          for (int i = 0; i < 6; i++) {
              System.out.println("主线程运行次数" + i);
          }
  		//线程不一定是立即执行的，实际的执行需要看CPU的调度，基本是随机调度，随机执行。因为CPU的执行一个线程的速度非常快，所以我们感觉起来像是在同时执行多个线程，但是实际上是一个一个线程执行的
  
      }
  

  Thread类使用案例：下载网图

  import org.apache.commons.io.FileUtils;
  import java.io.File;
  import java.io.IOException;
  import java.net.URL;
  
  //联系Thread：实现多线程图片下载器
  public class Testing02 extends Thread{
  	//声明私有变量
      private String url;
      private String name;
  	//构造方法
      public Testing02(String url , String name){
          this.url = url;
          this.name = name;
      }
      //下载图片的线程体
      public void run(){
          WebDownloader w1 = new WebDownloader();
          w1.downloader(url , name);
          System.out.println("下载了文件名为：" + name);
      }
  
      public static void main(String[] args) {
          Testing02 t1 = new Testing02("http://image.biaobaiju.com/uploads/20190227/22/1551276917-PGHykpWFAn.jpeg","1.jpeg");
          t1.start();
      }
  }
  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异常，downloader方法出现问题");
          }
      }
  

• 通过实现Runnable创建线程

  • 定义Runnable类实现Runnable接口
  • 实现run()方法，编写线程执行体
  • 创建线程对象，调用start（）方法启动线程
  • runnable实现类的运行还需要借助创建Thread对象

  public class Testing03 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接口的实现类对象
          Testing03 t3 = new Testing03();
          new Thread(t3).start();
      }
  }
  
  

  一般在Java中推荐使用通过Runnable类实现线程，这是由Java的单继承性质决定的，使用Runnable接口，就可以实现用多个线程对同一对象进行操作了

  同样的，多线程操作同一个对象也带来一个问题，被操作的对象会很容易出现数据异常等问题，所以还需要通过Java并发控制来解决

  //模拟用户抢票（由于没有加入并发控制，所有执行结果会出现两个人抢到同一张票的错误）
  public class Testing04 implements Runnable{
  
      private int ticketNums = 10;
      @Override
      public void run() {
          while(true){
              //调用sleep方法，人为制造延迟
              try {
                  Thread.sleep(200);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              if (ticketNums <= 0){
                  break;
              }
  
              System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNums-- + "张票");
          }
      }
  
      public static void main(String[] args) {
          Testing04 tt = new Testing04();
  		//实现多线程操作同一个对象tt
          new Thread(tt,"小米").start();
          new Thread(tt,"华为").start();
          new Thread(tt,"oppo").start();
      }
  

• 实现Callable接口（了解即可）

  1. 需要返回数值

  2. 重写call方法，需要抛出异常

  3. 创建目标对象

  4. 创建执行服务

     //这里有线程池的方法
     ExecutorService ser = Executors.newFixedThreadPool(3);
     

  5. 提交执行

     Future<Boolean> r1 = ser.submit(t1);
     Future<Boolean> r2 = ser.submit(t2);
     Future<Boolean> r3 = ser.submit(t3);
     

  6. 获取结果

     boolean re1 = r1.get();
     boolean re2 = r2.get();
     boolean re3 = r3.get();
     

  7. 关闭服务

     ser.shutdown();