多线程学习笔记

 

多线程学习

进程与线程

进程

进程是一个具有一定独立功能的程序在一个数据集上的一次动态执行的过程,是操作系统进行资源分配和调度的一个独立单位,是应用

程序运行的载体。至少有 5 种基本状态:初始态,执行态,等待状态,就绪状态,终止状态

线程

线程是程序执行时的最小单位,线程是CPU调度和分派的基本单位,它可与同属一个进程的其他的线程共享进程所拥有的全部资源

进程和线程的关系

线程是进程的一部分,一个线程只能属于一个进程,而一个进程可以有多个线程,但至少有一个线程

进程是资源分配的最小单位,线程是程序执行的最小单位。

进程和线程的区别

理解它们的差别,我从资源使用的角度出发。(所谓的资源就是计算机里的中央处理器,内存,文件,网络等等)

根本区别:进程是操作系统资源分配的基本单位,而线程是任务调度和执行的基本单位

开销方面:每个进程都有独立的代码和数据空间(程序上下文),进程之间切换开销大;线程可以看做轻量级的进程,同一类线程共享代码和数据空间,每个线程都有自己独立的运行栈和程序计数器(PC),线程之间切换的开销小

所处环境:在操作系统中能同时运行多个进程(程序);而在同一个进程(程序)中有多个线程同时执行(通过CPU调度,在每个时间片中只有一个线程执行)

内存分配:系统为每个进程分配不同的内存空间;而对线程而言,除了CPU外,系统不会为线程分配内存(线程所使用的资源来自其所属进程的资源),线程组之间只能共享资源

包含关系:线程是进程的一部分,所以线程也被称为轻权进程或者轻量级进程

 

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

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

 

  • 多线程:指的是这个程序(一个进程)运行时产生了不止一个线程

  • 并行与并发:

    • 并行:多个cpu实例或者多台机器同时执行一段处理逻辑,是真正的同时。

    • 并发:通过cpu调度算法,让用户看上去同时执行,实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源,那么针对这个公用的资源往往产生瓶颈,我们会用TPS或者QPS来反应这个系统的处理能力。

       

并发与并行

  • 线程安全:经常用来描绘一段代码。指在并发的情况之下,该代码经过多线程使用,线程的调度顺序不影响任何结果。这个时候使用多线程,我们只需要关注系统的内存,cpu是不是够用即可。反过来,线程不安全就意味着线程的调度顺序会影响最终结果,如不加事务的转账代码:

     void transferMoney(User from, User to, float amount){
       to.setMoney(to.getBalance() + amount);
       from.setMoney(from.getBalance() - amount);
     }
  • 同步:Java中的同步指的是通过人为的控制和调度,保证共享资源的多线程访问成为线程安全,来保证结果的准确。如上面的代码简单加入@synchronized关键字。在保证结果准确的同时,提高性能,才是优秀的程序。线程安全的优先级高于性能。

     

线程的实现

线程的几种实现方式

image-20201019195552569

 

继承Thread类
Thread01类
 package com.aly.dxc;
 
 /**
  * @author aly
  * @version 1.0
  * @date 2020/10/19 20:14
  */
 //线程创建学习:继承Thread类 重写run()方法编写线程执行体 创建线程对象,调用start()启动线程
 public class Thread01 extends Thread {
 
     @Override
     public void run() {
         //run()方法线程体
         for (int i = 0; i < 20; i++) {
             System.out.println("Aly正在学习多线程"+i);
        }
    }
 
     //主线程
     public static void main(String[] args) {
 
         //创建一个线程对象
         Thread01 Thread01 = new Thread01();
         //调用start()方法开启线程
         //注意:线程开启不一定立即执行,由CPU调度执行
         Thread01.start();
 
         for (int i = 0; i < 1000; i++) {
             System.out.println("Aly要努力哦"+i);
        }
    }
 }
 

!(C:\Users\luoHison\AppData\Roaming\Typora\typora-user-images\image-20201019211724129.png)

image-20201019211807500

Thread02类

 package com.aly.dxc;
 
 import org.apache.commons.io.FileUtils;
 
 import java.io.File;
 import java.io.IOException;
 import java.net.URL;
 
 /**
  * @author aly
  * @version 1.0
  * @date 2020/10/19 20:47
  */
 //联系Thread,实现多线程同步下载图片
 public class Thread02 extends Thread{
     public String url;
     public String fileName;
 
     public Thread02(String url, String fileName) {
         this.url = url;
         this.fileName = fileName;
    }
 
     //下载图片线程的执行体
     @Override
     public void run() {
         WebDownloader webDownloader = new WebDownloader();
         webDownloader.downloader(url,fileName);
         System.out.println("下载了文件名为:"+fileName);
    }
 
     public static void main(String[] args) {
         Thread02 t1 = new Thread02("https://portrait.gitee.com/uploads/avatars/user/2607/7821498_luoxiansong_1594880341.png","Aly01.png");
         Thread02 t2 = new Thread02("https://portrait.gitee.com/uploads/avatars/user/2607/7821498_luoxiansong_1594880341.png","Aly02.png");
         Thread02 t3 = new Thread02("https://portrait.gitee.com/uploads/avatars/user/2607/7821498_luoxiansong_1594880341.png","Aly03.png");
         t1.start();
         t2.start();
         t3.start();
    }
 }
 
 class WebDownloader{
     //下载方法
     public  void downloader(String url,String fileName){
         try {
             FileUtils.copyURLToFile(new URL(url), new File(fileName));
        } catch (IOException e) {
             e.printStackTrace();
             System.out.println("Io异常,downloader方法");
        } finally {
        }
    }
 
 }

image-20201019211637117

 

实现Runnable接口

Runnable01类

 package com.aly.dxc;
 
 /**
  * @author aly
  * @version 1.0
  * @date 2020/10/19 20:14
  */
 //线程创建学习:实现runnable接口 重写run()方法 执行线程需要丢入runnable接口实现类 调用start()方法
 public class Runnable01 extends Thread {
 
     @Override
     public void run() {
         //run()方法线程体
         for (int i = 0; i < 20; i++) {
             System.out.println("Aly正在学习多线程"+i);
        }
    }
 
     //主线程
     public static void main(String[] args) {
 
         //创建一个线程对象
         Runnable01 Thread01 = new Runnable01();
 
         new Thread(Thread01).start();
 
         for (int i = 0; i < 1000; i++) {
             System.out.println("Aly要努力哦"+i);
        }
    }
 }
 

image-20201019213856484

Runnable02类

 package com.aly.dxc;
 
 import org.apache.commons.io.FileUtils;
 
 import java.io.File;
 import java.io.IOException;
 import java.net.URL;
 
 /**
  * @author aly
  * @version 1.0
  * @date 2020/10/19 20:47
  */
 //练习实现Runnable接口,实现多线程同步下载图片
 public class Runnable02 implements Runnable{
     public String url;
     public String fileName;
 
     public Runnable02(String url, String fileName) {
         this.url = url;
         this.fileName = fileName;
    }
 
     //下载图片线程的执行体
     @Override
     public void run() {
         WebDownloader1 webDownloader = new WebDownloader1();
         webDownloader.downloader(url,fileName);
         System.out.println("下载了文件名为:"+fileName);
    }
 
     public static void main(String[] args) {
         Thread02 t1 = new Thread02("https://portrait.gitee.com/uploads/avatars/user/2607/7821498_luoxiansong_1594880341.png","Aly01.png");
         Thread02 t2 = new Thread02("https://portrait.gitee.com/uploads/avatars/user/2607/7821498_luoxiansong_1594880341.png","Aly02.png");
         Thread02 t3 = new Thread02("https://portrait.gitee.com/uploads/avatars/user/2607/7821498_luoxiansong_1594880341.png","Aly03.png");
         new Thread(t1).start();
         new Thread(t2).start();
         new Thread(t3).start();
    }
 }
 
 class WebDownloader1{
     //下载方法
     public  void downloader(String url,String fileName){
         try {
             FileUtils.copyURLToFile(new URL(url), new File(fileName));
        } catch (IOException e) {
             e.printStackTrace();
             System.out.println("Io异常,downloader方法");
        } finally {
        }
    }
 
 }

image-20201019214057796

 

实现Callable接口
 package com.aly.dxc;
 
 import org.apache.commons.io.FileUtils;
 
 import java.io.File;
 import java.io.IOException;
 import java.net.URL;
 import java.util.concurrent.*;
 
 /**
  * @author aly
  * @version 1.0
  * @date 2020/10/19 23:08
  */
 //线程创建方式三:实现Callable接口
 //好处:可以自定义返回值 可以抛出异常
 public class Callable implements java.util.concurrent.Callable<Boolean> {
     public String url;
     public String fileName;
 
     public Callable(String url, String fileName) {
         this.url = url;
         this.fileName = fileName;
    }
 
     //下载图片线程的执行体
     @Override
     public Boolean call() {
         WebDownloader2 webDownloader = new WebDownloader2();
         webDownloader.downloader(url, fileName);
         System.out.println("下载了文件名为:" + fileName);
         return true;
    }
 
     public static void main(String[] args) throws ExecutionException, InterruptedException {
         Callable t1 = new Callable("https://portrait.gitee.com/uploads/avatars/user/2607/7821498_luoxiansong_1594880341.png", "Aly01.png");
         Callable t2 = new Callable("https://portrait.gitee.com/uploads/avatars/user/2607/7821498_luoxiansong_1594880341.png", "Aly02.png");
         Callable t3 = new Callable("https://portrait.gitee.com/uploads/avatars/user/2607/7821498_luoxiansong_1594880341.png", "Aly03.png");
 
         //创建执行服务
         ExecutorService ser = Executors.newFixedThreadPool(3);
 
         //提交执行
         Future<Boolean> r1 =  ser.submit(t1);
         Future<Boolean> r2 =  ser.submit(t2);
         Future<Boolean> r3 =  ser.submit(t3);
 
         //获取结果
         boolean rs1 = r1.get();
         boolean rs2 = r2.get();
         boolean rs3 = r3.get();
 
         System.out.println(rs1);
         System.out.println(rs2);
         System.out.println(rs3);
 
         //关闭服务
         ser.shutdown();
    }
 }
 
 class WebDownloader2 {
     //下载方法
     public void downloader(String url, String fileName) {
         try {
             FileUtils.copyURLToFile(new URL(url), new File(fileName));
        } catch (IOException e) {
             e.printStackTrace();
             System.out.println("Io异常,downloader方法");
        } finally {
        }
    }
 
 }
 

image-20201020181552787

 

静态代理

 package com.aly.dxc;
 
 /**
  * @author aly
  * @version 1.0
  * @date 2020/10/20 13:33
  */
 //静态代理模式总结:真实对象与代理对象都要实现同一个接口 代理对象要代理真实角色
 //好处:代理对象可以做很多真实对象做不了的事情
 public class StaticProxy {
 
     public static void main(String[] args) {
         You you = new You();//你要结婚
         WeddingCompany weddingCompany = new WeddingCompany(you);
         weddingCompany.HappyMarry();
    }
 }
 
 interface Marry {
     void HappyMarry();
 }
 
 //真实对象 你去结婚
 class You implements Marry {
 
     @Override
     public void HappyMarry() {
         System.out.println("Aly结婚了");
    }
 }
 
 //婚庆公司 代理角色帮助你结婚
 class WeddingCompany implements Marry {
     //代理谁 真实目标角色
     private Marry target;
 
     public WeddingCompany(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("婚庆收尾款");
    }
 }
 
 

image-20201020181405386

 

Lamda表达式

  • 避免匿名内部类过多

  • 可以让你的代码看起来很简洁

  • 去掉了一堆没有意义的代码,只留下核心逻辑

  • 理解函数式接口是学习java8 lambda表达式的关键所在

    函数式接口的定义:

    任何接口,如果只包含唯一一个抽象方法,那么他就是一个函数式接口

     public interface Runnable{
      public abstract void run();
     }

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

 

推导lambda表达式见Lambda01类

package com.aly.dxc;

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/20 14:07
 */
//推导lambda表达式
public class Lambda01 {

    //3.静态内部类
    static class Like1 implements ILike {
        @Override
        public void lambda() {
            System.out.println("i like lambda1,静态内部类");
        }

        public static void main(String[] args) {
            ILike like = new Like();
            like.lambda();

            like = new Like1();
            like.lambda();

            //4.局部内部类
            class Like2 implements ILike {
                @Override
                public void lambda() {
                    System.out.println("i like lambda2,局部内部类");
                }
            }

            like = new Like2();
            like.lambda();

            //5.匿名内部类 没有类的名称 必须借助接口或者父类
            like = new ILike() {
                @Override
                public void lambda() {
                    System.out.println("i like lambda3,匿名内部类");
                }
            };
            like.lambda();

            //6.lambda简化
            like = () -> {
                System.out.println("i like lambda4,lambda简化");
            };
            like.lambda();
        }
    }
}

//1.定义一个函数式接口 :任何接口,如果只包含唯一一个抽象方法,那么他就是一个函数式接口
interface ILike {
    void lambda();
}

//2.实现类
class Like implements ILike {

    @Override
    public void lambda() {
        System.out.println("i like lambda,实现类");
    }
}

image-20201020181435887

 

简化lambda表达式见Lambda02类

package com.aly.dxc;

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/20 15:18
 */
//总结:
    //lambda表达式只有一行的代码的情况下才能简化成一行,如果有多行则需要花括号进行包裹
    //使用lambda的前提是必须为函数式接口
    //多个参数可以去掉参数类型,要去掉就全部去掉,而且必须留下括号
public class Lambda02 {

    public static void main(String[] args) {
        String n = "aly";
        String m = "lkk";
        sayHi sayHi = null;

        //匿名内部类
        sayHi = new sayHi() {
            @Override
            public void saySomething(String a, String b) {
                System.out.println(a + "love" + b);
            }
        };
        sayHi.saySomething(m, n);

        //lambda表达式
        sayHi = (String a, String b) -> {
            System.out.println(a + "love" + b);
        };
        sayHi.saySomething(m, n);

        //简化lambda去掉类型
        sayHi = (a, b) -> {
            System.out.println(a + "love" + b);
        };
        sayHi.saySomething(m, n);

        //简化lambda去掉花括号
        sayHi = (a, b) -> System.out.println(a + "love" + b);
        sayHi.saySomething(m, n);
    }
}


interface sayHi {
    void saySomething(String a, String b);
}

image-20201020181518650

 

线程状态

image-20201020174417138

image-20201020174454924

 

 

image-20201020174544505

停止线程

  • 不推荐使用JDK提供的stop() ,destory()方法【已废弃】

  • 推荐线程自己停止下来

  • 建议使用一个标志位进行终止变量,当flag=false,则终止线程运行

    package com.aly.dxc.state;
    
    /**
     * @author aly
     * @version 1.0
     * @date 2020/10/20 17:54
     */
    public class TestStop implements Runnable {
    
        //1.线程中定义线程体使用的标识
        private boolean flag = true;
    
        @Override
        public void run() {
            int i = 0;
            //2.线程使用标识
            while (flag) {
                System.out.println("run....thread" + i++);
            }
        }
    
        //3.设置一个公开的方法停止线程,转换标志位
        private void stop() {
            this.flag = false;
        }
    
        public static void main(String[] args) {
            TestStop testStop = new TestStop();
            new Thread(testStop).start();
            for (int i = 0; i < 1000; i++) {
                System.out.println("main" + i);
                if (i == 500) {
                    //调用stop方法切换标志位,让线程停止
                    testStop.stop();
                    System.out.println("线程该停止了");
                }
            }
        }
    }
    

    image-20201020181653988

 

线程睡眠

  • sleep(时间)指定当前线程阻塞的毫秒数

  • sleep存在异常interruptedException

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

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

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

模拟倒计时

package com.aly.dxc.state;

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/20 18:34
 */
//模拟倒计时
public class TestSleep {

    public static void main(String[] args) throws InterruptedException {
        tenDown();
    }

    public static void tenDown() throws InterruptedException {
        int num = 10;
        while (true) {
            Thread.sleep(1000);
            System.out.println(num--);
            if (num <= 0) {
                break;
            }
        }
    }
}

image-20201020184202214

网络延时

package com.aly.dxc.state;

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

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/20 18:42
 */
//打印系统时间
public class TestSleep01 {
    public static void main(String[] args) {
        Date startDateTime = new Date(System.currentTimeMillis());//获取系统当前时间
        while (true) {
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(startDateTime));
                startDateTime = new Date(System.currentTimeMillis());//更新当前时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
            }
        }
    }
}

image-20201020185051228

 

线程礼让

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

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

  • 让CPU从新调度,礼让不一定成功!看CPU心情

package com.aly.dxc.state;

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/20 18:59
 */
//线程礼让测试
//礼让不一定成功 看CPU心情
public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield, "aly").start();
        new Thread(myYield, "lkk").start();
    }
}

class MyYield implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName() + "线程结束执行");
    }
}

礼让:

image-20201020190421332

不礼让:

image-20201020190446859

 

Join

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

  • 可以想象成插队

package com.aly.dxc.state;

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/20 19:11
 */
//测试Join方法 可以想象成插队
public class TestJoin implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.println("线程VPI来了" + i);
        }
    }

    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++) {
            if (i == 50) {
                thread.join();
            }
            System.out.println("Main线程" + i);
        }
    }
}

image-20201020191704073

 

线程状态观测

Thread.State

线程状态。线程可以处于以下状态之一

  • NEW 尚未启动的线程处于此状态

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

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

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

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

  • TERMINATED 已退出的线程处于此状态

package com.aly.dxc.state;

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/20 19:32
 */
//观察测试线程的状态
public class TestState {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("aly");
        });

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

        //观察启动后
        thread.start();//启动线程
        state = thread.getState();
        System.out.println(state);//RUN

        while (state != Thread.State.TERMINATED) {//只要线程不终止就一直输出状态
            Thread.sleep(100);
            state = thread.getState();
            System.out.println(state);//更新线程状态
        }

    }
}

image-20201020194248597

 

线程的优先级

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

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

    Thread.MIN_PRIORITY = 1; Thread.MIN_PRIORITY = 10; Thread.MIN_PRIORITY = 5;

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

    getPriority() setPriority(int XXX)

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

package com.aly.dxc.state;

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/20 19:56
 */
//设置优先级
public class TestPriority {

    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();

        Thread t1 = new Thread(myPriority,"t1");
        Thread t2 = new Thread(myPriority,"t2");
        Thread t3 = new Thread(myPriority,"t3");
        Thread t4 = new Thread(myPriority,"t4");
        Thread t5 = new Thread(myPriority,"t5");

        //先设置优先级 再执行
        t1.setPriority(4);
        t1.start();

        t2.setPriority(6);
        t2.start();

        t3.setPriority(2);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY=10
        t4.start();

        t5.setPriority(5);
        t5.start();
    }
}

class MyPriority implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

image-20201020200400902

 

守护(daemon)线程

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

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

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

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

package com.aly.dxc.state;

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/20 20:15
 */
//测试守护线程
//上帝守护着你
public class TestDaemon {

    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();

        Thread thread1 = new Thread(you);
        thread1.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 = 0; i < 36000; i++) {
            System.out.println("一生都在快乐的活着");
        }
        System.out.println("永别了,世界----");
    }
}

image-20201020202201795

 

线程同步

多个线程操作同一个资源

并发:同一个对象被多个线程操作

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

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

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

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

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

线程不安全

package com.aly.dxc.syn;

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/20 20:51
 */
//不安全买票
public class UnSafeBuyTicket implements Runnable {

    //票
    int ticketNum = 10;
    private boolean flag = true;//停止方式

    public static void main(String[] args) {
        UnSafeBuyTicket station = new UnSafeBuyTicket();

        Thread thread = new Thread(station,"lkk");
        Thread thread1 = new Thread(station,"aly");
        Thread threa2 = new Thread(station,"hnd");

        thread.start();
        thread1.start();
        threa2.start();
    }


    @Override
    public void run() {
        //买票
        while (flag) {
            try {
                sfYp();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void sfYp() throws InterruptedException {
        //判断是否有票
        if (ticketNum <= 0) {
            flag = false;
            return;
        }
        //模拟延时
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName() + "买到了" + ticketNum--);
    }
}

image-20201020214413782

 

package com.aly.dxc.syn;

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/20 21:14
 */
//不安全取钱
public class UnSafeBank {

    public static void main(String[] args) {
        UnSafeBank unSafeBank = new UnSafeBank();
        Account account = new Account("结婚基金", 100.00);

        BankDrawing you = new BankDrawing(account, 50.00, "you", 0);
        BankDrawing girlFriend = new BankDrawing(account, 80.00, "you girlFriend", 0);

        you.start();
        girlFriend.start();
    }


}

//账户
class Account {
    String name;//名字
    Double money;//余额

    public Account(String name, Double money) {
        this.money = money;
        this.name = name;
    }
}

//银行:模拟取款
class BankDrawing extends Thread {

    Account account;//账户
    //取了多少钱
    Double drawingMoney;
    //手上有多少钱
    Double nowMoney;

    public BankDrawing(Account account, Double drawingMoney, String name, double nowMoney) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
        this.nowMoney = nowMoney;
    }

    //取钱
    @Override
    public void run() {
        //判断有没有钱
        if (account.money - drawingMoney < 0) {
            System.out.println(Thread.currentThread().getName() + "钱不够,取不了了");
            return;
        }

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //卡内余额
        account.money = account.money - drawingMoney;
        //你手里的钱
        nowMoney = nowMoney + drawingMoney;

        System.out.println(account.name + "余额为:" + account.money);
        //Thread.currentThread().getName()=this.getName()
        System.out.println(this.getName() + "手里的钱:" + nowMoney);
    }
}

image-20201020214630174

package com.aly.dxc.syn;

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

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/20 21:48
 */
//线程不安全的集合
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(4000);

        System.out.println(list.size());
    }
}

image-20201020215233043

 

同步方法

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

    缺陷:若将一个大的方法申明为synchronizrd将会影响效率

 

同步块

  • 同步块:synchronized(obj){}

  • obj称之为同步监视器

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

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

  • 同步监视器的执行过程

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

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

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

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

    package com.aly.dxc.syn;
    
    /**
     * @author aly
     * @version 1.0
     * @date 2020/10/20 20:51
     */
    //不安全买票->安全买票 加入synchronized
    public class UnSafeBuyTicket implements Runnable {
    
        //票
        int ticketNum = 10;
        private boolean flag = true;//停止方式
    
        public static void main(String[] args) {
            UnSafeBuyTicket station = new UnSafeBuyTicket();
    
            Thread thread = new Thread(station, "lkk");
            Thread thread1 = new Thread(station, "aly");
            Thread thread2 = new Thread(station, "hnd");
    
            thread.start();
            thread1.start();
            thread2.start();
        }
    
    
        @Override
        public synchronized void run() {
            //买票
            while (flag) {
                try {
                    sfYp();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        private void sfYp() throws InterruptedException {
            //判断是否有票
            if (ticketNum <= 0) {
                flag = false;
                return;
            }
            //模拟延时
            Thread.sleep(100);
            System.out.println(Thread.currentThread().getName() + "买到了" + ticketNum--);
        }
    }

image-20201021101004956

 

package com.aly.dxc.syn;

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/20 21:14
 */
//银行取钱 不安全->线程安全 加入synchronized
public class UnSafeBank {

    public static void main(String[] args) {
        UnSafeBank unSafeBank = new UnSafeBank();
        Account account = new Account("结婚基金", 100.00);

        BankDrawing you = new BankDrawing(account, 50.00, "you", 0);
        BankDrawing girlFriend = new BankDrawing(account, 80.00, "you girlFriend", 0);

        you.start();
        girlFriend.start();
    }


}

//账户
class Account {
    String name;//名字
    Double money;//余额

    public Account(String name, Double money) {
        this.money = money;
        this.name = name;
    }
}

//银行:模拟取款
class BankDrawing extends Thread {

    Account account;//账户
    //取了多少钱
    Double drawingMoney;
    //手上有多少钱
    Double nowMoney;

    public BankDrawing(Account account, Double drawingMoney, String name, double nowMoney) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
        this.nowMoney = nowMoney;
    }

    //取钱
    @Override
    public void run() {
        synchronized (account) {//线程安全
            //判断有没有钱
            if (account.money - drawingMoney < 0) {
                System.out.println(Thread.currentThread().getName() + "钱不够,取不了了");
                return;
            }

            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //卡内余额
            account.money = account.money - drawingMoney;
            //你手里的钱
            nowMoney = nowMoney + drawingMoney;

            System.out.println(account.name + "余额为:" + account.money);
            //Thread.currentThread().getName()=this.getName()
            System.out.println(this.getName() + "手里的钱:" + nowMoney);
        }
    }
}

image-20201021101052772

 

package com.aly.dxc.syn;

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

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/20 21:48
 */
//集合不安全 ->集合安全 加入synchronized
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(() -> {
                synchronized (list) {//锁代码块
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }

        Thread.sleep(3000);

        System.out.println(list.size());
    }
}

image-20201021101809539

 

package com.aly.dxc.state;

import java.util.concurrent.CopyOnWriteArrayList;

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/21 17:59
 */
//测试JUC安全类型的集合
public class TestJUC {
    
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(() -> {
                list.add(Thread.currentThread().getName());
            }).start();
        }

        try {
            Thread.sleep(3000);
            System.out.println(list.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

image-20201021180302305

 

死锁

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

  • obj称之为同步监视器

    死锁避免方法

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

    1.互斥条件:一个资源只能被一个进程使用

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

    3.不剥夺条件:进程已获得的资源,在未使用完之前,不能强行剥夺

    4.循环等待条件:若干进程之间形成之中头尾相连的循环等待资源关系

    只需破上述的任意一个或多个条件即可避免死锁

    package com.aly.dxc.syn;
    
    /**
     * @author aly
     * @version 1.0
     * @date 2020/10/21 18:16
     */
    //死锁:多个线程相互抱着对方需要的资源,然后形成僵持
    public class DeadLock {
    
        public static void main(String[] args) {
            MakeUp makeUp = new MakeUp(1, "lkk");
            MakeUp makeUp1 = new MakeUp(2, "aly");
            makeUp.start();
            makeUp1.start();
        }
    }
    
    //口红
    class Lipstick {
    
    }
    
    //镜子
    class Mirror {
    
    }
    
    //化妆
    class MakeUp extends Thread {
    
        //需要的资源只有一份,用static来保证只有一份
        static Lipstick lipstick = new Lipstick();
        static Mirror mirror = new Mirror();
    
        int choose;//选择
        String girlName;//使用化妆品的人
    
        MakeUp(int choose, String girlName) {
            this.choose = choose;
            this.girlName = girlName;
        }
    
        @Override
        public void run() {
            try {
                makeup();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        private void makeup() throws InterruptedException {
            if (choose == 1) {
                synchronized (lipstick) {
                    System.out.println(this.girlName + "拿到了口红");
                    Thread.sleep(1000);
                }
                synchronized (mirror) {
                    System.out.println(this.girlName + "拿到了镜子");
                }
    
            } else {
                synchronized (mirror) {
                    System.out.println(this.girlName + "拿到了镜子");
                    Thread.sleep(2000);
                }
                synchronized (lipstick) {
                    System.out.println(this.girlName + "拿到了口红");
                }
            }
            
        }
    }

image-20201021184459744

 

Lock锁

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

  • ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock

package com.aly.dxc.syn;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/21 18:54
 */
//测试Lock锁
public class TestLock {

    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }

}


class TestLock2 implements Runnable {

    private int ticketNum = 10;

    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if (ticketNum > 0) {

                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNum--);
                } else {
                    break;
                }
            } finally {
                lock.unlock();
            }

        }
    }
}

image-20201021191116704

 

synchronized与Lock的对比

  • Lock是显示锁(手动开启和关闭锁),synchronized是隐式锁,出了作用域自动释放

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

  • 使用Lock锁,JVM将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性(提供更好的子类)

  • 优先使用顺序:

    Lock>同步代码块(已经进入了方法体,分配了相应的资源)>同步方法(在方法体之外)

 

线程通信

  • Java提供了几个方法解决线程之间的通信问题

    方法名作用
    wait() 表示线程一直等待,直到其他线程通知,与sleep不同,会释放锁
    wait(long timeout) 指定等待的毫秒数
    notify() 唤醒一个处于等待状态的线程
    notifyAll() 唤醒同一个对象上所有调用wait()方法的线程,优先级高的线程优先调度

    注意:均是Object类的方法,都只能在同步方法或者同步代码块中使用,否则会抛出异常

    package com.aly.dxc.syn;
    
    /**
     * @author aly
     * @version 1.0
     * @date 2020/10/21 19:49
     */
    //测试:生产者消费者模型-->利用缓冲区解决:管程法
    //生产者,消费者,产品,缓冲区
    public class TestPC {
        public static void main(String[] args) {
            SynContainer synContainer = new SynContainer();
            new Productor(synContainer).start();
            new Custom(synContainer).start();
        }
    }
    
    //生产者
    class Productor extends Thread {
    
        SynContainer synContainer;
    
        Productor(SynContainer synContainer) {
            this.synContainer = synContainer;
        }
    
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                synContainer.push(new Chicken(i));
                System.out.println("生产了" + i + "只鸡");
            }
        }
    }
    
    //消费者
    class Custom extends Thread {
        SynContainer synContainer;
    
        Custom(SynContainer synContainer) {
            this.synContainer = synContainer;
        }
    
        @Override
        public void run() {
            System.out.println("消费者消费了"+synContainer.pop().id + "只鸡");
        }
    }
    
    //产品
    class Chicken {
        int id;
    
        Chicken(int id) {
            this.id = id;
        }
    }
    
    //缓冲区
    class SynContainer {
    
        //容器大小
        Chicken[] chickens = new Chicken[10];
    
        //容器计数器
        int count = 0;
    
        //生产者放入产品
        public synchronized void push(Chicken chicken) {
    
            //判断容器是否已经满了,如果满了,则需要等待
            if (chickens.length == count) {
                //生产等待
                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;
        }
    }

image-20201021202602804

 

package com.aly.dxc.syn;

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/21 20:35
 */
//测试生产者消费者2:信号灯法,标志位解决
public class TestPC2 {

    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();

    }
}

//生产者->演员
class Player extends Thread {

    TV tv;

    Player(TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (100 % 2 == 0) {
                this.tv.play("快乐大本营播放中");
            } else {
                this.tv.play("抖音观看中");
            }
        }
    }
}

//消费者->观众
class Watcher extends Thread {
    TV tv;

    Watcher(TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}

//产品->节目
class TV {

    String voice;//表演的节目
    boolean flag = true; //t演员表演 f观看节目

    //演员表演,观众等待
    public synchronized void play(String voice) {
        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了" + voice);
        //通知观众观看
        this.notifyAll();
        this.voice = voice;
        this.flag = !this.flag;
    }

    //观看节目,演员等待
    public synchronized void watch() {
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了" + voice);
        //通知演员表演
        this.notifyAll();
        this.flag = !this.flag;
    }
}

image-20201021205250538

 

线程池

  • 线程池的概念:

线程池就是首先创建一些线程,它们的集合称为线程池。使用线程池可以很好地提高性能,线程池在系统启动时即创建大量空闲的线程,程序将一个任务传给线程池,线程池就会启动一条线程来执行这个任务,执行结束以后,该线程并不会死亡,而是再次返回线程池中成为空闲状态,等待执行下一个任务。

  • 线程池的工作机制

    在线程池的编程模式下,任务是提交给整个线程池,而不是直接提交给某个线程,线程池在拿到任务后,就在内部寻找是否有空闲的线程,如果有,则将任务交给某个空闲的线程。 ​ 一个线程同时只能执行一个任务,但可以同时向一个线程池提交多个任务。

  • 使用线程池的原因: 多线程运行时间,系统不断的启动和关闭新线程,成本非常高,会过渡消耗系统资源,以及过渡切换线程的危险,从而可能导致系统资源的崩溃。这时,线程池就是最好的选择了。

    我们详细的解释一下为什么要使用线程池?

    在java中,如果每个请求到达就创建一个新线程,开销是相当大的。在实际使用中,创建和销毁线程花费的时间和消耗的系统资源都相当大,甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外,活动的线程也需要消耗系统资源。如果在一个jvm里创建太多的线程,可能会使系统由于过度消耗内存或“切换过度”而导致系统资源不足。为了防止资源不足,需要采取一些办法来限制任何给定时刻处理的请求数目,尽可能减少创建和销毁线程的次数,特别是一些资源耗费比较大的线程的创建和销毁,尽量利用已有对象来进行服务。

    线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重复使用线程,线程创建的开销就被分摊到了多个任务上了,而且由于在请求到达时线程已经存在,所以消除了线程创建所带来的延迟。这样,就可以立即为请求服务,使用应用程序响应更快。另外,通过适当的调整线程中的线程数目可以防止出现资源不足的情况。

使用线程池

ExecutorService和Executor

  • ExecutorService:真正的线程池接口。常用的子类ThreadPoolExecutor

void executor(Runnable command):执行任务命令,没有返回值,值班用来执行Runnable

<T> Future<T> submit(Callable<T> task):执行任务,有返回值,一般用来执行Callable

void shutdown():关闭连接池

  • Executor:工具类,线程池的工厂类,用于创建并返回不同类型的线程池

package com.aly.dxc.syn;

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

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/21 20:59
 */
//测试线程池
public class TestPool {
    public static void main(String[] args) {
        //1.创建服务,创建线程池
        //newFixedThreadPool 参数为:线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);

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

        //3.关闭连接
        service.shutdown();
    }

}

class MyThread implements Runnable {

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

image-20201021211636285

 

总结

package com.aly.dxc.syn;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/21 21:23
 */
//总结
public class ThreadNew {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        new MyThread1().start();
        new Thread(new MyThread2()).start();

        FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread3());
        new Thread(futureTask).start();
        Integer integer = futureTask.get();
        System.out.println(integer);
    }
}


//继承Thread
class MyThread1 extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread1");
    }
}

//实现Runnable接口
class MyThread2 implements Runnable {

    @Override
    public void run() {
        System.out.println("MyThread2");
    }
}

//实现Callable接口
class MyThread3 implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println("MyThread3");
        return 100;
    }
}

 

posted @ 2021-02-27 15:00  秋分的秋刀鱼  阅读(64)  评论(0)    收藏  举报