进程、线程和多线程

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

• 进程则是执行程序的一次执行过程，是一个动态的概念，使系统分配资源的单位

• 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程。线程是CPU调度和执行的单位

• 线程的创建：

  1. Thread class ： 继承Thread类（重点）
  2. Runnable接口 ： 实现Runnable接口（重点）
  3. Callable接口 ： 实现Callable接口（了解）

• 总结

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

  创建线程方式1：继承Thread类，重写run()方法，调用start开启线程

  //线程开启不一定立即执行，由cpu调度执行
  public class TestThread extends Thread{
      @Override
      public void run(){
          //run方法线程体
          for(int i = 0; i < 500; i++){
              System.out.println("run方法----->"+i);
          }
      }
      
      public static void main(String[] args){
          //main线程，主线程
          //创建一个线程对象
          TestThread testThread = new TestThread();
          //调用start()方法，开启线程
          testThread.start();
          
          for(int i = 0; i < 1000; i++){
              System.out.println("main方法----->"+i);
          }
      }
  }
  

  创建线程方式2：实现Runnable接口，重写run方法，执行线程需要丢入Runnable接口实现类，调用start方法

  public class TestThread implements Runnable{
      @Override
      public void run(){
          //run方法线程体
          for(int i = 0; i < 500; i++){
              System.out.println("run方法----->"+i);
          }
      }
      
      public static void main(String[] args){
          //main线程，主线程
          //创建Runnable接口的实现类对象
          TestThread testThread = new TestThread();
          
          //创建线程对象，通过线程对象来开启线程（代理）
          Thread thread = new Thread(testThread);
          
          //调用start()方法，开启线程
          thread.start();
          
          for(int i = 0; i < 1000; i++){
              System.out.println("main方法----->"+i);
          }
      }
  }
  

  创建线程方式3：实现Callable接口

  好处：1.可以定义返回值；2.可以抛出异常

  public class TestThread implements Callable<Boolean>{
      @Override
      public Boolean call(){
          //call方法线程体
          for(int i = 0; i < 500; i++){
              System.out.println("call方法----->"+i);
          }
          return true;
      }
      
      public static void main(String[] args) throws ExecutionException,InterruptedException{
          //main线程，主线程
          //创建Callable接口的实现类对象
          TestThread testThread = new TestThread();
          
          //创建执行服务
          ExecutorService ser = Executors.newFixedThreadPool(3);
          
          //提交执行
          Future<Boolean> future = ser.submit(testThread);
          
          for(int i = 0; i < 1000; i++){
              System.out.println("main方法----->"+i);
          }
          
          //获取结果
          boolean result = future.get();
          
          //关闭服务
          ser.shutdownNow();
          
      }
  }
  

  例1：多线程同步下载图片

  //导入commons-io.jar包
  public class TestThread implements Runnable{
      
      private String url; //网络图片名字
      private String name; //保存的文件名
      
      public TestThread(String url, String name){
          this.url = url;
          this.name = name;
      }
      
      @Override
      public void run(){
          WebDownloader webDownloader = new WebDownloader();
          webDownloader.downloader(url,name);
          System.out.println("下载的文件名为：" + name);
      }
      
      public static void main(String[] args){
          TestThread t1 = new TestThread("https://img-blog.csdnimg.cn/20210406172713692.png","图1.jpg");
          TestThread t2 = new TestThread("https://img-blog.csdnimg.cn/20210407165015472.png","图2.jpg");
          TestThread t3 = new TestThread("https://img-blog.csdnimg.cn/20210331115351847.png","图3.jpg");
         
          new Thread(t1).start();
          new Thread(t2).start();
          new Thread(t3).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方法出现问题");
          }
      }
  }
  

  例2：多个线程同时操作同一个对象

  问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱

  //购买火车票
  public class TestThread 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){
          TestThread ticket = new TestThread();
          
          new Thread(ticket,"线程1").start();
          new Thread(ticket,"线程2").start();
          new Thread(ticket,"线程3").start();
      }
  }
  /*
  运行结果：（数据紊乱重复）
  
  线程2---->拿到了第10张票
  线程1---->拿到了第9张票
  线程3---->拿到了第9张票
  线程1---->拿到了第8张票
  线程2---->拿到了第7张票
  线程3---->拿到了第7张票
  线程2---->拿到了第6张票
  线程1---->拿到了第5张票
  线程3---->拿到了第6张票
  线程3---->拿到了第4张票
  线程2---->拿到了第2张票
  线程1---->拿到了第3张票
  线程1---->拿到了第1张票
  线程2---->拿到了第-1张票
  线程3---->拿到了第0张票
  */
  

  例3：龟兔赛跑

  public class Race implements Runnable{
  
  	//胜利者
  	private  static String winner;
  	
  	@Override
  	public void run() {
  		for(int i = 0; i <= 100; i++) {
  			
  			//模拟兔子睡觉
  			if(Thread.currentThread().getName().equals("兔子") && i%10 == 0) {
  				try {
  					Thread.sleep(1);
  				} catch (InterruptedException e) {
  					e.printStackTrace();
  				}
  			}
  			
  			//判断比赛是否结束
  			boolean flag = gameOver(i);
  			//如果比赛结束,停止
  			if(flag) {
  				break;
  			}
  			
  			System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
  		}
  	}
  	
  	//判断是否完成比赛
  	private boolean gameOver(int steps) {
  		
  		//判断是否有胜利者
  		if(winner != null) {//已经存在胜利者
  			return true;
  		}
  		if(steps >= 100) {
  			winner = Thread.currentThread().getName();
  			System.out.println("winner is " + winner);
  			return true;
  		}
  		return false;
  	}
  	
  	public static void main(String[] args) {
  		Race race = new Race();
  		
  		new Thread(race,"乌龟").start();
  		new Thread(race,"兔子").start();
  	}
  
  }