多线程

线程简介

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

进程(Process)：在操作系统中运行的程序就是进程，是一个动态的概念，是系统资源分配的单位。

线程(Thread)：通常一个进程中可以包含若干个线程，线程是CPU调度和执行的单位，独立执行的路径。

多线程：真正的多线程是具有多个CPU的、即多核、如服务器；模拟出来的多线程只有一个CPU，因为切换的很快，所有就有同时执行的错觉。

线程核心：

线程的三种创建方式：

• 继承Thread类

  1. 自定义线程类继承Thread类

  2. 重写run()方法，编写线程执行体

  3. 创建线程对象，调用start()方法启动线程

  对于run()方法和start()方法：

  

  run()方法是规规矩矩的，run()来了就先走完run()方法再继续主线程，而start()方法则start()来了就调用run()方法，并且主线程和子线程并行交替执行

  一般而言，我们都是调用start()方法，而不是调用run()方法

   

  用多线程下载图片的例子

  package com.ge.demo01;
  ?
  ?
  import org.apache.commons.io.FileUtils;
  ?
  import java.io.File;
  import java.io.IOException;
  import java.net.URL;
  ?
  //练习Thread，实现多线程同步下载图片
  public class TestThread2 extends Thread{
  ?
      private String url;//网络图片地址
      private String name;//保存的文件名
  ?
      public TestThread2(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) {
          TestThread2 t1 = new TestThread2("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fa3.att.hudong.com%2F35%2F34%2F19300001295750130986345801104.jpg&refer=http%3A%2F%2Fa3.att.hudong.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1618031636&t=5ed56a3daeaa5339720c17d4b61a414b","1.jpg");
          TestThread2 t2 = new TestThread2("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fa0.att.hudong.com%2F30%2F29%2F01300000201438121627296084016.jpg&refer=http%3A%2F%2Fa0.att.hudong.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1618031396&t=b0ec2ebc0ee5c0faefb374a213a091bc","2.jpg");
          TestThread2 t3 = new TestThread2("https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fa0.att.hudong.com%2F52%2F62%2F31300542679117141195629117826.jpg&refer=http%3A%2F%2Fa0.att.hudong.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1618031769&t=cba6b77e67dc2aedacf5f8bbfabe2dfd","3.jpg");
  ?
          t1.start();
          t2.start();
          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方法出现问题");
          }
      }
  }
  ?

   

   

• 实现Runnable接口

  1. 定义MyRunnable类实现Runnable接口

  2. 实现run()方法，编写线程执行体

  3. 创建线程对象，调用start()方法启动线程

     代码实例

     package com.ge.demo01;
     ?
     //创建线程方式2：实现runnable接口，重写run方法，执行线程需要丢入runnable接口的实现类，调用start方法
     public class TestThread3 implements Runnable{
     ?
         @Override
         public void run() {
             for (int i = 0; i < 20; i++) {
                 System.out.println("我是线程大大大大大大任务："+i);
             }
         }
     ?
         public static void main(String[] args) {
     ?
             //创建Runnable接口的实现类TestThread3
             TestThread3 testThread3 = new TestThread3();
     ?
             //创建一个Thread实例，同时传入testThread3
             Thread thread = new Thread(testThread3);
     ?
             //调用thread对象中的start方法，叫做代理
             thread.start();
     ?
             for (int i = 0; i < 1000; i++) {
                 System.out.println("我在学习多线程："+i);
             }
     ?
         }
     ?
     }
     ?

对比前面两种方法，建议使用实现Runnable这种方法，因为其避免了OOP单继承的局限性，灵活方便，方便同一个对象被多个线程使用

小作业，龟兔赛跑

package com.ge.demo01;
?
public class Race implements Runnable{
?
?
    //胜利者
    private static String winner;
?
    //判断比赛是否结束
    boolean gameOver = false;
?
    @Override
    public void run() {
        for (int i = 1; i <= 100&&gameOver==false; i++) {
            if(Thread.currentThread().getName().equals("乌龟")){
                try {
                    Thread.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName() + "跑了第" + i + "步");
            if(i==100&&gameOver==false){
                winner = Thread.currentThread().getName();
                gameOver=true;
                System.out.println(Thread.currentThread().getName()+"赢得了比赛");
            }
        }
    }
?
    public static void main(String[] args) {
        Race race = new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}
?

• 实现Callable接口

  1. 实现Callable接口，需要返回值类型

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

  3. 创建目标对象

  4. 创建服务—>关闭服务

  Callable好处：

• 可以定义返回值

• 可以抛出异常

静态代理

静态代理模式：

- 真实对象和代理对象都要实现同一个接口
- 代理对象要代理真实角色

好处：代理对象可以做很多真实对象做不了的事情

真实对象专注做自己的事情

代码如下

package com.ge.Demo01;
?
public class StaticProxy {
    public static void main(String[] args) {
        MarryCompany marryCompany = new MarryCompany(new Person());
        marryCompany.happyMarry();
    }
?
}
?
interface Marry{
    //结婚这件事的编码
    void happyMarry();
}
?
//真实对象，结婚的人
class Person implements Marry{
    @Override
    public void happyMarry() {
        System.out.println("结婚啦！");
    }
}
?
//代理对象，婚庆公司
class MarryCompany implements Marry{
?
    //代理谁—>真实目标角色
    private  Marry target;
?
    public MarryCompany(Marry target) {
        this.target = target;
    }
?
    @Override
    public void happyMarry() {
        after();
        this.target.happyMarry();//这就是真实对象
        later();
    }
?
    private void later() {
        System.out.println("结婚后，收拾");
    }
?
    private void after() {
        System.out.println("结婚前，布置场景");
    }
}

类比多线程的思想可知：

Thread就好比婚庆公司，它们分别代理了Runnable和happyMarry（）。

Lamda表达式（λ）

意义：避免匿名内部类定义过多，用简单的代码代替复杂的内容，其实质属于函数式编程的概念。

首先，了解函数式接口：

• Functional Interface（函数式接口）是学习Java8 lambda表达式的关键所在

• 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。

• 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象

类型展示：

love = a->System.out.println("i love you-->"+a);

总结：

• lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹

• 前提是接口为函数式接口

• 多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号

线程状态

• 线程停止

  //1. 建议线程正常停止———>利用次数，不建议死循环
  //2. 建议使用标志位————>设置一个标志位
  //3. 不要使用stop或者destroy等过时或者JDK不建议使用的方法

• 线程休眠（sleep）

  package com.ge.state;
  ?
  import java.text.SimpleDateFormat;
  import java.util.Date;
  ?
  ?
  public class TestSleep2 {
      //模拟倒计时
      static public void tenDown() throws InterruptedException {
          int num = 10;
          while(true){
              Thread.sleep(1000);
              System.out.println("倒计时："+num--);
              if(num<0){
                  break;
              }
          }
      }
      
      //持续打印系统时间
      static public void printDate(){
          Date startDate = new Date(System.currentTimeMillis());
  ?
          while(true){
              try {
                  Thread.sleep(1000);
                  System.out.println(new SimpleDateFormat("HH:mm:ss").format(startDate));
                  startDate = new Date(System.currentTimeMillis());
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
      }
  ?
      public static void main(String[] args) throws InterruptedException {
          tenDown();
          printDate();
      }
  }
  ?

• 线程礼让

  • 让当前正在执行的线程暂停，但不阻塞

  • 将线程从运行状态转为就绪状态

  • 让cpu重新调度，礼让不一定成功！看CPU心情……

  package com.ge.state;
  
  
  //测试礼让线程
  //礼让不一定成功，看CPU心情
  public class TestYield implements Runnable{
  
      public static void main(String[] args) {
  
          new Thread(new TestYield(),"A").start();
          new Thread(new TestYield(),"B").start();
  
      }
  
      @Override
      public void run() {
          System.out.println(Thread.currentThread().getName()+"线程开始执行");
          Thread.yield();
          System.out.println(Thread.currentThread().getName()+"线程停止");
      }
  }
  
  
  

• Join

  • Join合并线程，待此线程执行完成后，再执行其它线程，其它线程阻塞

  • 可以想象成插队

    package com.ge.state;
    
    //测试join方法
    //想象为插队
    public class TestJoin implements Runnable{
    
        public static void main(String[] args) throws InterruptedException {
            TestJoin testJoin = new TestJoin();
            Thread thread = new Thread(testJoin);
            thread.start();
    
            for (int i = 0; i < 1000; i++) {
                System.out.println("main方法在路上"+i);
                if(i==200){
                    thread.join();
                }
            }
        }
    
    
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                System.out.println("vip来了"+i);
            }
        }
    }
    

• 线程几个状态的观测代码

package com.ge.state;


//观察测试线程的状态
public class TestState {

    public static void main(String[] args) throws InterruptedException {
        //建立线程——>睡眠五次，每次一秒，用lambda方法
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("/////");
        });


        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);

        //观察启动后
        thread.start();
        //再获取一次状态
        state = thread.getState();
        System.out.println(state);


        //只要线程不终止，就一直获取观察
        while (state!=Thread.State.TERMINATED){
            Thread.sleep(100);
            state = thread.getState();
            System.out.println(state);
        }
    }
}

• 线程的优先级

  • 线程的优先级用数字表示，范围从1~10，数字越大优先级越大

  • 优先级只是一种概率问题，优先级高(比如10)并不是说这个线程就一定是最先执行的，只是优先执行的概率高一些而已，这都是看CPU的调度的

  • 每个线程刚创建时，优先级默认为5

示例代码：

package com.ge.state;

//测试线程的优先级
public class TestPriority {

    //一个main方法用于测试
    public static void main(String[] args) {

        //打印主线程的默认优先级
        System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());

        MyPrority myPrority = new MyPrority();
        Thread t1 = new Thread(myPrority);
        Thread t2 = new Thread(myPrority);
        Thread t3 = new Thread(myPrority);
        Thread t4 = new Thread(myPrority);
        Thread t5 = new Thread(myPrority);
        Thread t6 = new Thread(myPrority);

        //先设置优先级，然后再启动
        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);
        t4.start();

//        t5.setPriority(-1);
//        t5.start();
//
//        t6.setPriority(11);
//        t6.start();
    }

}

//一个实现Runnable接口的类
class MyPrority implements  Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
    }
}

• 守护(daemon)线程

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

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

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

  • 守护线程如：后台记录操作日之，监控内存，垃圾回收等

package com.ge.state;

public class TestDeamon {

    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        thread.setDaemon(true);//默认为false，设置为true后变成了守护线程
        thread.start();//上帝守护线程启动

        new Thread(new You()).start();//用户线程启动
    }

}

class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("上帝守护着你");
        }
    }
}

class You implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i <= 36500; i++) {
            System.out.println("你活了："+i+"天");
        }
        System.out.println("离开这个美丽的世界");
    }
}

• 线程同步

  • 并发：同一个对象被多个线程同时操作（1万个人抢一张票）

  • 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候我就需要线程同步，其实就是一种机制，多个需要同时访问此对线的线程进入对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用

  • 队列和锁(每个对象都拥有一把锁)：synchronized

  线程不安全例子（原因是每个线程用各自的内存）：

  1. 银行取钱

  2. 抢票机制

  3. List，代码如下：

package com.ge.syn;

import java.util.ArrayList;
import java.util.List;

//线程不安全的集合List<>
//原因是多条线程有可能同一时间插入到List的同一位置
public class UnSafeList {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        Thread.sleep(3000);
        System.out.println(list.size());
    }
}

如何解决线程不安全的问题？

使用synchronized方法和synchronized块

• synchronized方法控制对“对象"的访问，每个对象对应一把锁，

• 缺陷，若将一个大的方法申明为synchronized将会影响效率，方法里面需要修改的内容才需要加锁，锁的太多，浪费资源

下面是实例一，采用的是synchronized块

package com.ge.syn;

//不安全的取钱
//两个人去银行取钱
public class UnsafeBank {
    public static void main(String[] args) {
        //设置账户
        Account account = new Account(1000, "Marry");
        //两个线程
        Drawing me = new Drawing(account, 50, "me");
        Drawing girlfriend = new Drawing(account, 100, "girlfriend");

        me.start();
        girlfriend.start();
    }
}

//账户类
class Account {
    int money;
    String name;
    public Account(int money,String name){
        this.money=money;
        this.name=name;
    }
}


//银行：模拟取款
class Drawing extends Thread{
    //你打算取多少钱
    int drawingMoney;
    //你口袋剩余的钱
    int nowMoney;
    //你的账户
    Account account;
    //构造方法
    public Drawing(Account account,int drawingMoney,String name){
        super(name);
        this.account=account;
        this.drawingMoney=drawingMoney;

    }

    //取钱的过程，重写run方法
    @Override
    public void run() {

        //锁的对象就是变化的量
        synchronized (account){if(drawingMoney>account.money){
            System.out.println(Thread.currentThread().getName()+"余额不足！");
            return;
        }

            //sleep可以放大问题的发生性
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //成功取钱,账户余额减少
            account.money=account.money-drawingMoney;
            //口袋里的钱增加
            nowMoney = nowMoney + drawingMoney;

            //打印你的账户余额
            System.out.println(account.name+"余额为："+account.money);
            //打印你口袋里的钱（this.getName()=Thread.currentThread().getName()）
            System.out.println(this.getName()+"口袋里的钱"+nowMoney);
        }
        }
}

注意：Thread.sleep这个方法加进去是很有必要的，有时候主线程（main）都跑完了，其它线程还没跑完，会导致打印的结果不是预料中的（即使提前加了锁）

死锁：

两个或者多个线程都在等待对方释放资源，都停止执行的情形

化妆品的例子：

package com.ge.thread;


//死锁
public class DeadLock {
    public static void main(String[] args) {
        Makeup g1 = new Makeup(0, "灰姑娘");
        Makeup g2 = new Makeup(1, "白雪公主");
        new Thread(g1).start();
        new Thread(g2).start();
    }
}

//口红
class Lipstick{

}

//镜子
class Mirror{

}

//产生死锁的类
class Makeup implements Runnable{

    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;//选择
    String grilName;//使用化妆品的人

    public Makeup(int choice,String grilName){
        this.choice = choice;
        this.grilName = grilName;
    }

    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //互相持有对方需要的锁，又需要对方的锁
    private void makeup() throws InterruptedException {
        if(choice == 0){
            synchronized (lipstick){//获得口红的锁
                System.out.println(this.grilName+"获得口红的锁");
                Thread.sleep(1000);

            }synchronized (mirror){//一秒钟后想获得镜子
                System.out.println(this.grilName+"一秒钟后获得镜子的锁");
            }
        }else{
            synchronized (mirror){//获得镜子的锁
                System.out.println(this.grilName+"获得口红的锁");
                Thread.sleep(1000);

            }synchronized (lipstick){//一秒钟后想获得口红
                System.out.println(this.grilName+"一秒钟后获得镜子的锁");
            }
        }
    }
}

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

1. 互斥：一个资源每次只能被一个进程使用

2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放

3. 不剥夺资源：进程以获得的资源，在未使用完之前，不能强行剥夺

4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

对于上面的必要条件，我们只要破解其中一个就能避免死锁发生

多线程的学习

原文：https://www.cnblogs.com/PinkBird/p/14527611.html