Java的线程章节

目录

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

2.  一般有三类

3. 网图下载 （此过程中运用到了commons.io-2.6这个包）

4. 继承Thread类

实现Runnable接口

实现Callable接口

5. 龟兔赛跑

6. 静态代理模式

7. lamada表达式的由来

8. 线程的状态

9. 线程状态的检测

10. 线程优先级

11. 守护（daemon）线程

12. 处理多线程问题

13. 模拟账户取钱（线程存在不安全性）

14. 解决方法：

同步方法

同步块

同步监视器的执行过程

15. 死锁

16. Lock锁

17. 并发协作模式 ”生产者/消费者模式“ --->管程法

18. 并发协作模式 ”生产者/消费者模式“ --->信号灯法

---

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

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

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

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

对于同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制；

线程会带来额外的开销，如cpu调度时间，并发控制开销。

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

2.  一般有三类

Thread.class     继承Thread类(重点)

Runnable接口 实现Runnable接口(重点)

Callable接口 实现Callable接口(了解)

3. 网图下载 （此过程中运用到了commons.io-2.6这个包）

通过下载三张图片，我们可以发现图片下载的顺序和我们写的执行语句start顺序不一定是一样的。

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

//下载图片
public class ThreadDemo02 extends Thread{
    //定义图片的路径以及存放的路径
    String url,name;
    //构造器
    public ThreadDemo02(String url,String name){
      this.url = url;
      this.name = name;
    }

    //run 方法
    @Override
    public void run() {
        //线程运行,首先实例化我们定义的类，
        WebDownLoader webDownLoader = new WebDownLoader();

        //运用我们类中的方法
         webDownLoader.downLoader(url,name);
         System.out.println("已下载图片"+name);
    }

    public static void main(String[] args) {
      ThreadDemo02 t1 = new ThreadDemo02("https://tse1-mm.cn.bing.net/th/id/OIP-C.qcuVoKDLvNsTlWO342raUwHaEL?w=293&h=180&c=7&o=5&dpr=1.25&pid=1.7","t1");
      ThreadDemo02 t2 = new ThreadDemo02("https://tse1-mm.cn.bing.net/th/id/OIP-C.qcuVoKDLvNsTlWO342raUwHaEL?w=293&h=180&c=7&o=5&dpr=1.25&pid=1.7","t2");
      ThreadDemo02 t3 = new ThreadDemo02("https://tse1-mm.cn.bing.net/th/id/OIP-C.qcuVoKDLvNsTlWO342raUwHaEL?w=293&h=180&c=7&o=5&dpr=1.25&pid=1.7","t3");

      //执行
        t3.start();
        t2.start();
        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("download方法出现异常，无法执行");
        } finally {
        }
    }
}

4. 继承Thread类

子类继承Thread类具备多线程能力

启动线程： 子类对象.start()

不建议使用： 避免OOP单单继承局限性

实现Runnable接口

实现接口Runnable具有多线程能力

启动线程： 传入目标对象+Tread对象.start()

推荐使用： 避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

实现Callable接口

1. 需要返回值类型

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

3. 创建目标对象

4. 创建执行服务: ExecutorService ser = Executors.newFixedThreadPool(1);

5. 提交执行： Future<Boolean> result1 = ser.submit(t1);

6. 获取结果： boolean r1 = result1.get();

7. 关闭服务： ser.shutdownNow();

5. 龟兔赛跑

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("兔子")){
                try {
                    //兔子沉睡时间
                    Thread.sleep(0);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            if(isGameOver(i)){
              break;
            }
            System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
        }
    }

    //判断比赛是否结束
    public boolean isGameOver(int steps){
        if(winner != null){
            return true;
        }
        if(steps >= 100){
            winner = Thread.currentThread().getName();
            System.out.println(Thread.currentThread().getName()+"获得了胜利");
            return true;
        }
        return false;
    }


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

6. 静态代理模式

真实对象和代理对象都要实现同一个接口。

代理对象要代理真实的角色

优点：

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

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

案例：

public class StaticTest01 {
    public static void main(String[] args) {
       //实例化对象
       You you = new You();
      //实例化代理公司
        Company company = new Company(you);
        company.HappyMarry();
    }
}

//自定义Marry接口
interface Marry{
        void HappyMarry();
    }

 //真实结婚角色,你要去结婚
class You implements Marry{
     @Override
     public void HappyMarry() {
      System.out.println("我要结婚");
     }
 }

 //代理角色，帮助你结婚
class Company implements Marry{
    //定义一个Marry类型，用于接受角色所实现的方法。
    private Marry target;

     public Company(Marry target) {
         this.target = target;
     }

     @Override
     public void HappyMarry() {
      before(); //这是代理角色独有的方法
      this.target.HappyMarry(); //这是角色的方法
      after();  //这是代理角色独有的方法
     }
     private void before(){
         System.out.println("结婚之前，布置");
     }
     private void after(){
         System.out.println("结婚之后，收尾款");
     }

 }

7. lamada表达式的由来

public class Lambdal {

    //3. 静态内部类
    static class Love3 implements iLove{
        @Override
        public void Lambdal() {
            System.out.println("2");
        }
    }

    public static void main(String[] args) {
        //用接口实例化类
        iLove ilove = new Love2();
        ilove.Lambdal();
        ilove = new Love3();
        ilove.Lambdal();

        //4. 局部内部类
        class Love4 implements iLove{
            @Override
            public void Lambdal() {
                System.out.println("3");
            }
        }

        ilove = new Love4();
        ilove.Lambdal();


        //5. 匿名对象,通过接口去实现，算是表达式了，要加分号
         iLove a = new iLove(){
            @Override
            public void Lambdal() {
                System.out.println("4");
            }
        };
         a.Lambdal();

         //用lambda简化
        iLove iLike = ()->{
            System.out.println("5");
        };
        iLike.Lambdal();
    }



}

//1. 定义一个函数式接口----指的是只能有一个抽象类
interface iLove{
    void Lambdal();
}

//2. 实现类
class Love2 implements  iLove{
    public void Lambdal(){
        System.out.println("1");
    }
}

8. 线程的状态

Thread t = new Thread()线程对象一旦创建就进入到了新生状态

当调用start()方法，线程立即进入就绪状态，但不意味着立即调度状态，

进入运行状态，线程才真正执行线程体的代码块

当调用sleep，wait或同步锁定时，线程进入阻塞状态，就是代码不往下执行，堵塞时间解除后，重新进入就绪状态，等待cpu调度执行。

线程中断或者结束，一旦进入死亡状态，就不能再次启动。

9. 线程状态的检测

Thread.State 线程状态。线程可以处于以下状态之一：

NEW

尚未启动的线程处于状态。

RUNNABLE

在Java虚拟机中执行的线程处于此状态

BLOCKED

被阻塞等待监听器锁定的线程处于此状态

WAITING

正在等待另一个线程执行特定动作的线程处于此状态。

TIMED WAITTING

正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。

TERMINATED

public class StateTest {
    //监测线程状态
    public static void main(String[] args) throws InterruptedException {
        //lambdal表达式
        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);
        }
    }
}

已退出的线程处于此状态。

10. 线程优先级

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

Thread.MIN_PRIORITY = 1;

Thread.MAX_PRIORITY = 10;

Thread.NORM_PRIORITY = 5;

使用以下方式获取或改变优先级

getPriority(),setPriority(int xxx);

11. 守护（daemon）线程

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

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

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

如：后台记录操作日志，监控内存，垃圾回收等待

12. 处理多线程问题

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

由于同一个进程的多个线程共享同一个存贮空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可，存在以下问题：

 一个线程持有锁会导致其他所有需要此锁的线程挂起。

在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；

如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题。

13. 模拟账户取钱（线程存在不安全性）

public class AccountTest {
    public static void main(String[] args) {
     //实例化账户
        Account account = new Account(10000,"兴业银行");
     //创建老公、老婆这两条线程
        Draw husband = new Draw(account,"你",5000);
        Draw wife = new Draw(account,"妻子",10000);
        wife.start();
        husband.start();

    }
}


//账户,由余额和卡名组成
class Account {
 int money;
 String cardName;
    public Account(int money, String cardName) {
        this.money = money;
        this.cardName = cardName;
    }
}


//模拟取钱
class Draw extends Thread{
    Account account;
    //定义手里多少钱，取了多少钱
    int nowMoney,drawMoney;
 public Draw(Account account,String name,int drawMoney){
     super(name);
     this.account = account;
     this.drawMoney = drawMoney;
 }

 //取钱操作
    @Override
    public void run() {
       if(account.money-drawMoney<0){
           System.out.println(Thread.currentThread().getName()+" 你们的账户里已经没有余额了");
       }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //显示余额
        account.money = account.money - drawMoney;
       //显示手里的金额
        nowMoney = nowMoney + drawMoney;

        System.out.println(account.cardName+"余额为： "+ account.money);
        System.out.println(Thread.currentThread().getName()+"手里的余额为： "+ nowMoney);
    }
}

14. 解决方法：

同步方法

由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括了两种方法：synchronized方法和synchronized块。

        同步方法： public synchronized void method(int args){}

synchronized方法控制对"对象"的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会堵塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行

          若将一个大的方法申明为synchronized将会影响效率。

同步块

同步块： synchronized(Obj){ }

Obj 称之为同步监视器

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

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

同步监视器的执行过程

1. 第一个线程访问，锁定同步监视器，执行其中代码。

2. 第二个线程访问，发现同步监视器被锁定，无法访问。

3. 第一个线程访问完毕，解锁同步监视器。

4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问。

方法里面需要修改的内容才需要锁，锁太多，浪费资源

15. 死锁

1. 多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。

public class DeadLock {
    //死锁
    
    public static void main(String[] args) {
      MakeUp girl1 = new MakeUp(0,"白雪公主");
      MakeUp girl2 = new MakeUp(1,"灰姑娘");

      new Thread(girl1).start();
      new Thread(girl2).start();
    }
}

//镜子
class Mirror{

}


//口红
class LipStick{

}

class MakeUp extends Thread {
    //定义人名，选择
    int choice;
    String name;

    //定义存放两个类的变量
   static Mirror mirror = new Mirror();
   static LipStick lipStick = new LipStick();

   //构造方法
    public MakeUp(int choice,String name){
        this.choice = choice;
        this.name = name;
    }

    public void run(){
        if(choice ==0){
            //第一个人先拿镜子，后拿口红
            synchronized (mirror){
              System.out.println(name+"拿到了镜子");
              synchronized (lipStick){
                  System.out.println(name+"拿到了口红");
              }
            }
        }else{//第二个人先拿口红，再拿镜子
           synchronized (lipStick){
               System.out.println(name+"拿到了口红");
               synchronized (mirror){
                   System.out.println(name+"拿到了镜子");
               }
           }
        }
    }
}

16. Lock锁

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

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

使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性

优先使用顺序:

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

17. 并发协作模式 ”生产者/消费者模式“ --->管程法

生产者： 负责生产数据的模块（可能式方法，对象，线程，进程）；

消费者： 负责处理数据的模块（可能是方法，对象，线程，进程）；

缓冲区： 消费者不能直接使用生产者的数据，他们之间有个”缓冲区“

生产者将生产好的数据放入缓存区，消费者从缓冲区拿出数据。

//生产者，消费者，产品，缓冲区
public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Producer(container).start();
        new Customer(container).start();
    }

}

//定义生产者
class Producer extends Thread{
 //定义缓冲区
    SynContainer synContainer;

    public Producer(SynContainer synContainer) {
        this.synContainer = synContainer;
    }

    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            System.out.println("生产了"+i+"只鸡");
            //将数据放入缓冲区
            synContainer.push(new Chicken(i));
        }
    }
}

//定义消费者
class Customer extends Thread{
  //定义缓冲区
    SynContainer synContainer;
    public Customer(SynContainer synContainer){
        this.synContainer = synContainer;
    }

    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            //将数据从缓存区拿出
            System.out.println("消费后还剩下"+synContainer.pop().id);
        }
    }
}


//定义产品
class Chicken {
    //定义鸡的id号
    int id = 0;
    public Chicken(int id){
        this.id = id;
    }
}


//定义缓冲区
class SynContainer{
    //定义一个存放产品的空间
    Chicken[] chickens = new Chicken[10];

    //计数
    int count = 0;

    //产品的存放(防止线程不安全)
    public synchronized void push(Chicken chicken){
     if(count == chickens.length){
         //等待
         try {
             this.wait();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
     //如果没有满，就投入商品
     chickens[count] = chicken;
     count++;
     this.notifyAll();
    }

    //产品的消费
    public synchronized Chicken pop(){
        if (count == 0) {
            //等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果还存在产品，继续消费
        count--;
        Chicken chicken = chickens[count];

        //吃完后通知生产者
        this.notifyAll();
        return chicken;

    }

}

18. 并发协作模式 ”生产者/消费者模式“ --->信号灯法

通过标志位解决生产者/消费者模式。

public class TvTest {
    //测试生产者消费者问题2：信号灯法，标志位解决。
    public static void main(String[] args) {
      TV tv = new TV();
      new Actor(tv).start();
      new Watcher(tv).start();
    }
}

//通过标志位来控制线程的运行

//生产者-->演员
class Actor extends Thread{
   TV tv;
   public Actor(TV tv){
       this.tv = tv;
   }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if(i % 2 == 0){
                tv.act("果宝特工");
            }else{
                tv.act("熊出没");
            }
        }
    }
}


//消费者-->观众
class Watcher extends Thread{
    TV tv;
    public Watcher(TV tv){
        this.tv = tv;
    }

   public void run(){
       for (int i = 0; i < 20; i++) {
           if(i % 2 ==0){
               tv.watch("果宝特攻");
           }else{
               tv.watch("熊出没");
           }
       }
    }
}



//产品--->节目
class TV{
    //演员表演，观众等待  flag = T
    //观众观看，演员等待  flag = F
    String video; //表演节目名字
    boolean flag = true;

    //生产-->表演
    public synchronized void act(String video){
        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员正在表演："+video);
        // 通知观众观看
        this.flag = !this.flag;
        this.notify(); //通知唤醒
        this.video = video;
    }


    //消费-->观看
    public synchronized void watch(String video){
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观众正在观看"+video);
        //通知演员表演
        this.flag = !this.flag;
        this.notify(); //通知唤醒
        this.video = video;
    }

}

线程池

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

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

好处：

提高相应速度（见扫了创建新线程的时间）

降低资源消耗（重复利用线程池中的线程，不需要每次创建）

便于线程管理(......）

corePoolSize: 核心池的大小

maximumPoolSize: 最大线程数

keepAliveTime: 线程没有任务时最多保持多长时间后会终止。

ExecutorService:真正的线程池接口。

void  execute(Runnable command): 执行任务/命令，没有返回值，一般用来执行Runnable

void shutdown(): 关闭连接池

Executors： 工具类，线程池的工厂类，用于创建并返回不同类型的线程池。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestPool {
    //测试线程池
    public static void main(String[] args) {
        //1. 创建服务，创建线程池
        //newFixedThreadPool 参数为n 线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);

        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //关闭链接
        service.shutdown();
    }
}

class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}