并发&多线程基础

一、基本概念

进程
- 进程就是执行程序的一次执行过程,它是一个动态的概念,式系统资源分配的单位
- 通常再一个进程中可以包含若干个线程,当然一个进程中至少有一个线程,不然没有存在的意义,线程是CPU调度和执行的单位
线程
- 线程就是独立的执行路径
- 在程序运行时,即使没有自己创建线程,后台也会有多个线程,比如主线程,GC线程
- main()称之为主线程,为系统的入口,用于执行整个程序
- 在一个进程中,如果开辟了多个线程,线程的运行是由调度器安排调度的,调度器是与操作系统紧密相关的,先后顺序是不能人为干预的
- 对同一份资源操作时mm会存在资源抢夺的问题,需要加入并发控制
- 线程会带来额外的开销,如CPU调度时间,并发控制开销
- 每个线程在自己的工作内存交互,内存控制不当会造成数据不一致

1.1 创建线程的三种方式：

1. Thread class:

继承自Thread类,重写run方法,创建实例调用start方法

public class ThreadTest extends Thread {
    
    
    @Override
    public void run() {
    
    
        System.out.println(Thread.currentThread().getName() + "线程方法被调用了");
    }

    public static void main(String[] args) {
    
    
        ThreadTest threadTest = new ThreadTest();
        threadTest.start();
    }
}

也可以用threadTest.run();如果是run就会先执行run然后执行main方法，若是start那么同时执行。

案例：多线程下载图片：

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://static.now0.jpg","牛客网1.jpg");
        TestThread2 t2=new TestThread2("https://timgsa.baidu.com/timg?88.jpg","2.jpg");
        TestThread2 t3=new TestThread2("https://timgsa.baidu.com/timg?b.700_0.jpeg","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方法出现问题");
        }
    }
}

2.Runnable接口：

实现Runnable接口,重写run方法,创建Thread类时，作为参数传入,调用start方法

public class TestRunnable implements Runnable {
        
        
    @Override
    public void run() {
        
        
        System.out.println("实现了run方法");
    }
}

  public static void main(String[] args) {
        
        
        ThreadTest threadTest = new ThreadTest();
        threadTest.start();

        Thread thread = new Thread(new TestRunnable());
        thread.start();
    }
}

总结：

åœ¨è¿™é‡Œæ’å¥å›¾ç‰‡æè¿°

案例1：买票

多个线程操作同一个对象(线程并发问题)

//多个线程同时操作同一个对象
//买火车票的例子
//发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱
public class TestThread4 implements Runnable{
    
    
    //票数,权限控制所以最好用private
    private int ticketNums=10;

    @Override
    public void run() {
    
    
        while (true){
    
    
            if(ticketNums<=0){
    
    
                break;
            }
            //模拟延时
            try {
    
    
                Thread.sleep(500);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"票");
        }
    }

    public static void main(String[] args) {
    
    
        TestThread4 ticket=new TestThread4();
        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛").start();
    }
}

案例2：龟兔赛跑（单例模式）

package com.kuang.demo01;

//模拟龟兔赛跑
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 step){
    
    
        //判断是否有胜利者
        if(winner!=null){
    
    //已经存在胜利者
            return true;
        }
        if(step==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();
    }
}

3. 实现Callable接口

重写call方法

使用callable的好处：

可以定义返回值
可以抛出异常

package com.kuang.demo02;


import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

/**
 * 使用callable好处
 * 1.可以定义返回值
 * 2.可以跑出异常
 */
public class TestCallable implements Callable<Boolean> {
    
    
    // 网络图片地址
    private String url;
    // 保存到哪个的文件名
    private String name;

    public TestCallable(String url, String name) {
    
    
        this.url = url;
        this.name = name;
    }

    @Override
    public Boolean call() {
    
    
        WebDownloader webDownLoader = new WebDownloader();
        webDownLoader.downloader(url,name);
        System.out.println("下载了文件名为：" + name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
    
    
        TestCallable t1 = new TestCallable("https://wx3.sinaimg.cn/mw690/91722dd1ly1gde42g94laj21ho1zkhdt.jpg","祖儿1.jpg");
        TestCallable t2 = new TestCallable("https://wx2.sinaimg.cn/mw690/91722dd1ly1gde42j6jmpj21ho1zkhdt.jpg","祖儿2.jpg");
        TestCallable t3 = new TestCallable("https://wx3.sinaimg.cn/mw690/91722dd1ly3gd444pbhpaj216o1kw4qp.jpg","祖儿3.jpg");

        // 创建执行服务
        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();

        // 关闭服务
        ser.shutdown();
    }
}
//下载器
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方法出现问题");
        }
    }
}

1.2 静态代理

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

优点：
- 代理对象可以做很多真实对象做不了的事情
- 真实对象专注自己的事情

public class StaticProxy {
    
    
    public static void main(String[] args) {
    
    
        //8.实例代理对象，并执行方法
        ProxyYou proxyYou = new ProxyYou(new you());
        proxyYou.HappyMarry();
    }
}
//1.共同的接口
interface Marry{
    
    
    void HappyMarry();
}
//2.本身
class you implements Marry{
    
    
    //实现接口
    @Override
    public void HappyMarry() {
    
    
        System.out.println("本人非常开心~");
    }
}
//3.代理对象
class ProxyYou implements Marry{
    
    
    //4.目标对象
    private Marry target;
    //5.构造方法
    public ProxyYou(Marry target) {
    
    
        this.target = target;
    }
    //实现接口
    @Override
    public void HappyMarry() {
    
    
        System.out.println("代理你，结婚前");
        //6.调用目标对象方法
        this.target.HappyMarry();
        //7.aop思想
        System.out.println("代理你，结婚后");
    }
}

使用lambda表达式：

 		//8.实例代理对象，并执行方法
        new ProxyYou(new you()).HappyMarry();
        //对比
        new Thread(()->{
    
     System.out.println("和上面的静态代理如出一辙"); }).start();

1.3 Lamda表达式

λ希腊字母表中排序第十一位的字母，英语名称为Lamda
避免匿名内部类定义过多，去掉了一些没有意义的代码，
其实质属于函数式编程的概念
前提是函数式接口才能用lamda表达式

函数式接口的定义：

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

例如：Runnable接口源码：
```
@FunctionalInterface
public interface Runnable {
      
      
    public abstract void run();
}
```
对于函数式接口，我们可以通过lamda表达式来创建该接口的对象；

案例1：没有参数的

原来我们的习惯是：

//推导lamda表达式
public class TestLamda {
    
    
    public static void main(String[] args) {
    
    
        //3.接口new实现类
        StudyLamda you = new You();
        you.onlyone();
    }
}
//1.定义一个函数式接口
interface StudyLamda{
    
    
    //接口里的方法是抽象的，只包含一个抽象方法
    void onlyone();
}
//2.实现类
class You implements StudyLamda{
    
    
    @Override
    public void onlyone() {
    
    
        System.out.println("你正在学习lamda表达式");
    }
}

静态内部类，前面一定要加上static，还是在主方法之外的。

//推导lamda表达式
public class TestLamda {
    
    
    //2.静态内部类
    static class You implements StudyLamda{
    
    
        @Override
        public void onlyone() {
    
    
            System.out.println("你正在学习lamda表达式");
        }
    }
    public static void main(String[] args) {
    
    
        //3.接口new实现类
        StudyLamda you = new You();
        you.onlyone();
    }
}
//1.定义一个函数式接口
interface StudyLamda{
    
    
    //接口里的方法是抽象的，只包含一个抽象方法
    void onlyone();
}

局部静态类，将它放到了main方法中，去掉了static

//推导lamda表达式
public class TestLamda {
    
    
    public static void main(String[] args) {
    
    
        //4.局部内部类
        class You implements StudyLamda{
    
    
            @Override
            public void onlyone() {
    
    
                System.out.println("你正在学习lamda表达式");
            }
        }
        //3.接口new实现类
        StudyLamda you = new You();
        you.onlyone();
    }
}
//1.定义一个函数式接口
interface StudyLamda{
    
    
    //接口里的方法是抽象的，只包含一个抽象方法
    void onlyone();
}

匿名内部类：没有类的名称，必须借助接口（就像创建一个对象一样），在匿名内部类尾部加上；

//推导lamda表达式
public class TestLamda {
    
    
    public static void main(String[] args) {
    
    
        //匿名内部类
        StudyLamda studylamda = new StudyLamda() {
    
    
            @Override
            public void onlyone() {
    
    
                System.out.println("你正在学习lamda表达式");
            }
        };
        studylamda.onlyone();
    }
}
//1.定义一个函数式接口
interface StudyLamda{
    
    
    //接口里的方法是抽象的，只包含一个抽象方法
    void onlyone();
}

最终简化

public class TestLamda {
    
    
    //2.静态内部类
    public static void main(String[] args) {
    
    
        //lamda表达式
        StudyLamda studyLamda = ()->{
    
    
            System.out.println("你正在学习lamda表达式~");
        };
        studyLamda.onlyone();
    }
}
//1.定义一个函数式接口
interface StudyLamda{
    
    
    //接口里的方法是抽象的，只包含一个抽象方法
    void onlyone();
}

lamda表达的简化：

public class TestLamda2 {
    
    
    public static void main(String[] args) {
    
    
          A a = (String s)->{
    
    
                  System.out.println("lamda的简化过程！"+s);
          };
        //去掉参数类型
        a = (s)->{
    
    
            System.out.println("lamda的简化过程！"+s);
        };
        //简化括号
        a = s->{
    
    
            System.out.println("lamda的简化过程！"+s);
        };
        //简化花括号
        a = s->System.out.println("lamda的简化过程！"+s);
        a.B("4");
        /*
        总结：lamda表达式只能有一行代码情况下才能简化，前提是函数式接口
            参数可以去掉类型，要去掉就都去掉，多个要加括号
         */
    }
}
interface A{
    
    
    void B(String s);
}

案例2：带参数的

interface Ilove{
    
    
    void love(int a);
}

传统写法：

//实现类state
class Love implements Ilove{
    
    
    @Override
    public void love(int a) {
    
    
        System.out.println("i love you-->"+a);
    }
}

静态内部类：

public class TestLambda2 {
    
    
    静态内部类
    static class Love implements Ilove{
    
    
        @Override
        public void love(int a) {
    
    
            System.out.println("i love you-->"+a);
        }
    }
 }

局部内部类：

 public static void main(String[] args) {
    
    
//          局部内部类
        class Love implements Ilove{
    
    
            @Override
            public void love(int a) {
    
    
                System.out.println("i love you-->"+a);
            }
        }
     Ilove love=new Love();//向下转型
     love.love(2);
 }

匿名内部类：

 public static void main(String[] args) {
    
    
         //匿名内部类
        Ilove love=new Ilove() {
    
    
            @Override
            public void love(int a) {
    
    
                System.out.println("i love you-->"+a);
            }
        };
        love.love(2);
 }

lamda表达式：

 public static void main(String[] args) {
    
    
       Ilove love=(int a)->{
    
    
            System.out.println("i love you-->"+a);
        };
        love.love(2);
}

因为Runnable就是一个函数式接口，我们实现的时候，就可以使用lamda表达式：

1.4 线程状态

创建状态
就绪状态
阻塞状态
运行状态
死亡状态

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i5xJhuPZ-1592308713404)(C:\Users\车泽平\AppData\Roaming\Typora\typora-user-images\1592285267192.png)]$
在这里插入图片描述

线程方法

在这里插入图片描述

1. 线程停止

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

自己建立标志位的方式停止：

public class TestStop implements Runnable{
    
    
    //设置标志位
    private boolean flag = true;
    @Override
    public void run() {
    
    
        int i = 0;
        while (flag){
    
    
            System.out.println("ThreadStop！"+i++);
        }
    }
    public void s(){
    
    
        this.flag = false;
    }
    public static void main(String[] args) {
    
    
        TestStop testStop = new TestStop();
        new Thread(testStop).start();
        for (int i = 0; i < 800; i++) {
    
    
            //注意写上这个输出操作，不然时间太快，效果不能显示
            System.out.println("main"+i);
            if(i == 600){
    
    
                testStop.s();
                System.out.println("主线程中让线程停止了");
            }
        }
    }
}

2. 线程休眠

sleep(时间)指定当前线程阻塞的毫秒数
sleep存在异常interruptedexeception
sleep时间到达后线程进入就绪状态
sleep可以模拟网络延时，倒计时等
每一个对象都有一个锁，sleep不会释放锁

sleep案例-买票：

模拟网络延时:放大网络的不安全性

如果没有网络延时，票直接让小明拿走了，感觉没有问题，但是加上网络延时，就发生了许多问题。

import com.kuang.demo01.TestThread4;

//模拟网络延时:放大网络的不安全性
public class TestSleep implements Runnable {
    
    
    //票数,权限控制所以最好用private
    private int ticketNums=10;

    @Override
    public void run() {
    
    
        while (true){
    
    
            if(ticketNums<=0){
    
    
                break;
            }
            //模拟延时
            try {
    
    
                Thread.sleep(5);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"票");
        }
    }

    public static void main(String[] args) {
    
    
        TestThread4 ticket=new TestThread4();
        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛").start();
    }
}

sleep案例-模拟倒计时：

10 9 8 7 6 5 4 3 2 1

//模拟倒计时
public class TestSleep2 {
    
    
    public static void main(String[] args) {
    
    
        //倒计时
        try {
    
    
            tenDown();
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }

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

每隔1秒打印一下当前系统时间：

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.SimpleFormatter;
//模拟倒计时
public class TestSleep2 {
    
    
    public static void main(String[] args) {
    
    
        //打印当前系统时间
        Date startTime=new Date(System.currentTimeMillis());//获取系统当前时间
        while(true){
    
    
            try {
    
    
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime=new Date(System.currentTimeMillis());//更新当前时间
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
        }
    }
}

3. 线程礼让（yield）

礼让线程，让当前正在执行的线程暂停，但不阻塞
将线程从运行状态转为就绪状态
让CPU重新调度，礼让不一定成功，看CPU心情

public class TestYield {
    
    
    public static void main(String[] args) {
    
    
        MyYield myYield = new MyYield();
        new Thread(myYield,"A").start();
        new Thread(myYield,"B").start();
    }
}
class MyYield implements Runnable{
    
    
    @Override
    public void run() {
    
    
        System.out.println(Thread.currentThread().getName()+"输出完之后会礼让");
        Thread.yield();//让另一个线程跑，但不一定礼让成功
        System.out.println(Thread.currentThread().getName()+"礼让不一定成功");
    }
}

4. 线程强制执行（join）

少用会让线程阻塞

public class TestJoin implements Runnable{
    
    
    @Override
    public void run() {
    
    
        System.out.println("vip的线程来了~");
    }

    public static void main(String[] args) {
    
    
        TestJoin testJoin = new TestJoin();
        Thread thread =new Thread(testJoin);
        thread.start();
        //主线程
        for (int i = 0; i < 100; i++) {
    
    
            System.out.println("主线程"+i);
            if(i == 80){
    
    
                try {
    
    
                    //插队,可能会让线程阻塞
                    thread.join();
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
            }
        }
    }
}

5. 线程观测状态

线程状态。线程可以处于以下状态之一：
- NEW
  尚未启动的线程处于此状态。
- RUNNABLE
  在Java虚拟机中执行的线程处于此状态。
- BLOCKED
  被阻塞等待监视器锁定的线程处于此状态。
- WAITING
  正在等待另一个线程执行特定动作的线程处于此状态。
- TIMED_WAITING
  正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
- TERMINATED
  已退出的线程处于此状态。

public class TestState {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        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);//NEW

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

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

        }

    }
}

会出现：NEW、runnable、time_waiting、terminated，如果进入死亡状态就不可以再次启动了。

死亡之后的线程不能启动

6. 线程的优先级（PRIORITY）

ava提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程;线程调度器按照优先级决定该调度哪个线程来执行
线程的优先级用数字来表示,范围从1~10，数字越大优先级越高
- Thread.MIN_PRIORITY = 1
- Thread.MAX_PRIORITY= 10
- Thread.NORM_PRIORITY = 5
使用getPriority()和setPriority()来获取或改变优先级

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

    public static void main(String[] args) {
    
    
        //主线程默认优先级
        TestPriority testPriority = new TestPriority();
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        Thread a = new Thread(testPriority);
        Thread b = new Thread(testPriority);
        Thread c = new Thread(testPriority);
        //设置优先级，再启动
        a.setPriority(3);
        a.start();

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

        c.setPriority(Thread.MIN_PRIORITY);
        c.start();
    }
}

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

7. 守护线程

线程分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕例如：main
虚拟机不用等待守护线程执行完毕例如：GC线程，我们不用等待虚拟机的垃圾回收线程执行完毕
如：后台记录操作日志，垃圾回收等等。。。

//守护线程
public class TestGuard {
    
    
    public static void main(String[] args) {
    
    
        You you = new You();
        God god = new God();

        Thread b = new Thread(god);
        //默认是false，true之后为守护线程
        b.setDaemon(true);
        b.start();
        new Thread(you).start();
    }
}
//用户线程
class You implements Runnable{
    
    

    @Override
    public void run() {
    
    
        for (int i = 0; i < 100; i++) {
    
    
            System.out.println("用户线程正在执行");
        }
        System.out.println("gameover");
    }
}
//守护线程
class God implements Runnable{
    
    

    @Override
    public void run() {
    
    
        while(true){
    
    
            System.out.println("我是守护线程，守护着你");
        }
    }
}

1.5线程同步(synchronized)

并发：多个线程操作同一个资源

处理多线程问题时,多个线程访问同一个对象,并且某些线程还想修改这个对象,这时候我们就需要线程同步,线程同步其实是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面的线程使用完毕,下一个线程在使用
由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问的冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制syncronized,当一个线程获得对象的排他锁,独占资源,其他线程必须等待,使用后释放锁即可,存在以下问题：
- 一个线程持有锁会导致其他所有需要此锁的进程挂起
- 在多线程竞争的情况下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题
- 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置,引起性能问题

同步方法和同步块

同步块: synchronized(obj){}
obj称之为同步监视器
- obj可以是任何对象,但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器,因为同步方法中的同步监视器就是this,就是这个对象本身,或者是class
同步监视器的执行过程
- 第一个线程访问,锁定同步监视器,执行其中的代码
- 第二个线程访问,发现同步监视器被锁定,无法访问
- 第一个线程访问完毕,解锁同步监视器
- 第二个线程访问,发现同步监视器没有锁,然后锁定并访问
同步方法在方法上添加synchronized关键子,锁的是对象本身

三大不安全实例

1.买票问题

public class UnsafeBuyTicket implements Runnable{
    
    
    private int ticket = 10;
    @Override
    public void  run() {
    
    
        while(true){
    
    
            if(ticket<=0){
    
    
                break;
            }
            try {
    
    
                Thread.sleep(100);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"买了"+ticket--);
        }
    }

    public static void main(String[] args) {
    
    
        UnsafeBuyTicket unsafeBuyTicket = new UnsafeBuyTicket();
        new  Thread(unsafeBuyTicket,"A").start();
        new  Thread(unsafeBuyTicket,"B").start();
        new  Thread(unsafeBuyTicket,"C").start();
    }
}

**解决办法：synchronized解决此类问题 **

//不安全的买票
public class UnsafeBuyTicket {
    
    
    public static void main(String[] args) {
    
    
        BuyTicket station=new BuyTicket();
        new Thread(station,"我").start();
        new Thread(station,"你").start();
        new Thread(station,"牛").start();

    }
}
class BuyTicket implements Runnable{
    
    
    //票
    private int ticketNums=10;
    boolean flag=true;//外部停止方式；
    @Override
    public void run() {
    
    
        //买票
        while(flag){
    
    
            try {
    
    
                //sleep放在里面，每一个线程就会有机会
                Thread.sleep(1000);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            buy();
        }
    }
    //synchronized 变成同步方法
    private synchronized void buy()  {
    
    
        //判断是否有票
        if(ticketNums<=0){
    
    
            flag=false;
            return;
        }
        //模拟延时

        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

可以使用lock，查看下面Lock（ReentrantLock）

2.银行问题

package com.kuang.syn;

//两个人去银行取钱
public class UnsafeBank {
    
    
    public static void main(String[] args) {
    
    
        //账号
        Account account=new Account(1000,"结婚基金");
        Drawing you=new Drawing(account,50,"你");
        Drawing girlfriend=new Drawing(account,100,"girlfriend");
        you.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{
    
    
    Account account;//账户
    //取了多少钱
    int drawingMoney;
    //现在手里有多少钱
    int nowMoney;

    public Drawing(Account account, int drawingMoney, String name) {
    
    
        super(name);
        this.account=account;
        this.drawingMoney= drawingMoney;
    }
    //取钱
    public void run(){
    
    
        synchronized (account){
    
    
            //判断钱还有没有
            if(account.money-drawingMoney<0){
    
    
                System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
                return;
            }
            try {
    
    
                Thread.sleep(1000);
            } 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);
        }
    }
}

解决办法：synchronized 代码块，将这个代码块锁住，控制的是account这个变量。

synchronized(acount){
    
    }//锁住增删改查的对象

3.集合问题

问题的原因主要是多个数组在同一时间操作了同一个位置，覆盖掉了，所以原数据会少

结果会小于100

public class UnsafeList {
    
    
    public static void main(String[] args) {
    
    
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 100; i++) {
    
    
            new Thread(()->{
    
    
                list.add(Thread.currentThread().getName());
            }).start();
        }
        System.out.println(list.size());
    }
}

解决办法：synchronized 代码块

同时也要加上sleep让线程充分执行

import java.util.ArrayList;
import java.util.List;
//线程不安全的集合
//问题的原因主要是多个数组在同一时间操作了同一个位置，覆盖掉了，所以原数据会少
public class UnsafeList {
    
    
    public static void main(String[] args) {
    
    
        List<String> list=new ArrayList<String>();
        for (int i = 0; i <10000 ; i++) {
    
    
            new Thread(()->{
    
    
                synchronized (list){
    
    
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }

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

JUC下的CopyOnWriteArryList也行；

juc就是并发包，下面还有callable这个类

import java.util.concurrent.CopyOnWriteArrayList;

//测试JUC安全类型的集合
public class TestJUC {
    
    
    public static void main(String[] args) {
    
    
        CopyOnWriteArrayList<String> list=new CopyOnWriteArrayList<>();
        for (int i = 0; i < 1000; i++) {
    
    
            new Thread(()->{
    
    
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
    
    
            Thread.sleep(30);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

同步代码块会引起死锁

1.6 死锁

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

产生死锁的原因：
　　（1）因为系统资源不足。
　　（2）进程运行推进的顺序不合适。
　　（3）资源分配不当等。

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

互斥条件：一个资源每次只能被一个进程使用。
请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺
循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系

这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。

package com.kuang.DeadLock;
//死锁：多个线程互相抱着对方的需求资源
public class DeadLock {
    
    
    public static void main(String[] args) {
    
    
        Makeup g1=new Makeup(0,"灰姑娘");
        Makeup g2=new Makeup(1,"白雪公主");
        g1.start();
        g2.start();
    }
}
//口红
class Lipstick{
    
    
}
//镜子
class Mirror{
    
    
}
class Makeup extends Thread{
    
    
    //需要的资源只有一份，用static来保证
    static Lipstick lipstick =new Lipstick();
    static  Mirror mirror=new Mirror();
    int choice;//选择
    String girlName;//使用化妆品的人
    Makeup(int choice,String  girlName){
    
    
        this.choice=choice;
        this.girlName=girlName;
    }
    @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.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+"获得口红的锁");

                }
            }
        }
    }
}

解决方法：将上面的

 synchronized (mirror){
    
    //一秒钟之后想获得镜子
                    System.out.println(this.girlName+"获得镜子的锁");
                }

拿到外面来就好了。另一个也是同理，总之，不能抱住对方的锁就好。也就是解决上面产生死锁的四个必要条件之一就好了。

1.8 Lock锁

从JDK1.5开始,java提供了更为强大的线程同步机制——通过显示定义同步锁对象来实现同步,同步锁使用lock对象来充当
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象
ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中.比较常用的是ReentrantLock,可以显示加锁,释放锁

import java.util.concurrent.locks.ReentrantLock;

//测试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{
    
    
    int ticketNums=10;
    //定义lock锁
    private final ReentrantLock  lock=new ReentrantLock();

    @Override
    public void run() {
    
    
        while (true){
    
    

            try {
    
    
                lock.lock();//加锁；
                if(ticketNums>0){
    
    
                    try {
    
    
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
    
    
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                }else{
    
    
                    break;
                }
            }finally {
    
    
                //解锁
                lock.unlock();
            }

        }
    }
}

lock和synchronized对比

Lock是显示锁(手动开启和关闭,别忘记关闭锁) synchronized是隐式锁,出了作用域自动释放
Lock只有代码块锁,synchronized有代码块锁和方法锁
使用lock锁,JVM将花费较少的时间来调度线程,性能更好,并且具有更好的扩展性(提供更多的子类)
优先使用顺序
- Lock > 同步代码块（已经进入了方法体，分配了相应的资源）> 同步方法（在方法体外）

1.9 线程通信

生产者和消费者

生产者和消费者问题

假设仓库中只能存放一件产品,生产者将生产出来的产品放入仓库,消费者将仓库产品取走消费
如果仓库中没有产品,则生产者将产品放入仓库,否则停止生产并等待,直到仓库中的产品被消费者取走为止
如果仓库中放有产品,则消费者可以将产品取走消费,否则停止消费并等待,直到仓库中再次放入产品为止

这是一个线程同步问题,生产者和消费者共享一个资源,并且生产者和消费者之间相互依赖,互为条件

对于生产者,没有生产产品之前,要通知消费者等待,而生产了产品之后,又要马上通知消费者消费
对于消费者,在消费之后,要通知生产者已经结束消费,需要生产新的产品以供消费
在生产者消费者问题上,仅有synchronized是不够的
- synchronized可阻止并发更新同一个共享资源,实现了同步
- synchronized不能用来实现不同线程之间消息传递(通信)

生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的。

sleep和wait的区别：sleep就是抱着锁睡觉（不释放锁），wait会释放锁

解决方法1—管程法

并发协作模式"生产者/消费者模式" ===>管程法
- 生产者: 负责生产数据的模块(可能是方法,对象,线程,数组)
- 消费者: 负责处理数据的模块(可能是方法,对象,线程,数组)
- 缓冲区: 消费者不能直接使用生产者的数据,他们之间有个缓冲区
生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据

设置缓冲区Refrigerator

package com.kuang.gaoji;

/**
 * 管程法
 */

//测试：生产者消费者模型-利用缓冲区：管程法
//生产者、消费者、产品；缓冲区
public class TestPC {
    
    
    public static void main(String[] args) {
    
    
        SynContainer Container = new SynContainer();
        new productor(Container).start();
        new Consumer(Container).start();

    }

}
//生产者
class productor extends Thread{
    
    
    SynContainer container;
    public productor(SynContainer container){
    
    
        this.container=container;
    }
    //生产
    @Override
    public void run() {
    
    
        for (int i = 0; i < 100; i++) {
    
    
            container.push(new Chicken(i));
            System.out.println("生产了"+i+"只鸡");
        }
    }
}
//消费者
class Consumer extends Thread{
    
    
    SynContainer container;
    public Consumer(SynContainer container){
    
    
        this.container=container;
    }
    //消费
    @Override
    public void run() {
    
    
        for (int i = 0; i < 100; i++) {
    
    
            System.out.println("消费了-->"+container.pop().id+"只鸡");
        }
    }
}
//产品
class Chicken{
    
    
    int id;//产品编号

    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++;

        //可以通知消费者消费

    }
    //消费者消费产品
    public synchronized Chicken pop(){
    
    
        //判断能否消费
        if(count==0){
    
    
            //等待生产者生产，消费者等待
            try {
    
    
                this.wait();
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Chicken chicken = chickens[count];

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

解决方法2—信号灯法

设置标志位：flag，如果为true那就让它停，如果为false就让它继续

package com.kuang.gaoji;

/**
 * 信号灯法
 * 这个例子可以理解为电影上映，观众观看
 */
//测试生产者消费者问题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;
    public Player(TV tv) {
    
    
        this.tv = tv;
    }
    @Override
    public void run() {
    
    
        for (int i = 0; i < 20; i++) {
    
    
            if(i%2==0){
    
    
                this.tv.play("天天向上");
            }else{
    
    
                this.tv.play("广告");
            }
        }
    }
}
//消费者--->观众
class Watcher extends Thread{
    
    
    TV tv;

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

    @Override
    public void run() {
    
    
        for (int i = 0; i < 20; i++) {
    
    
            tv.watch();
        }
    }
}
//产品----->节目
class TV{
    
    
    //演员表演，观众等待 T
    //观众观看，演员等待 F
    //演员
    String voice;//表演的节目
    boolean flag=true;

    //表演
    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;
    }
}

2.1 线程池

背景: 经常创建和销毁,使用量特别大的资源,比如并发情况下的线程,对性能影响很大, 就好像共享单车一样，我们不需要每次骑车就买一辆新车。
思路: 提前创建好多个线程,放入线程池中,使用时直接获取,使用完毕放回池中,可以避免频繁的创建销毁,实现重复利用,类似生活中的工共交通工具
好处
- 提高了响应速度(减少了创建新线程的时间)
- 降低资源消耗(重复利用线程池中线程,不需要每次都创建)
- 便于线程管理(…)
  - corePoolSize: 核心池的大小
  - maximumPoolSize: 最大线程数
  - keepAliveTime: 线程没有任务时最多保持多长时间后会终止

线程池例子：

package com.kuang.gaoji;

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

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

        //2.关闭连接
        service.shutdown();
    }
}
class Mythread implements Runnable{
    
    
    @Override
    public void run() {
    
    
            System.out.println(Thread.currentThread().getName());

    }
}

shutdown和shutdownNow的区别

shutdown只是将线程池的状态设置为SHUTWDOWN状态，正在执行的任务会继续执行下去，没有被执行的则中断。

而shutdownNow则是将线程池的状态设置为STOP，正在执行的任务则被停止，没被执行任务的则返回。

多线程详解—基础