多线程Thread

01-概述

• 线程就是独立的执行路径;
• 在程序运行时,即便没有自己创建程,后台也会有多个线程,如主线程, gc线程;
• main()称之为主线程,为系统的入口,用于执行整个程序;
• 在一个进程中,如果开辟了多个线程,线程的运行由调度器安排调度,调度器是与操作系统紧密相关的,先后顺序是不能认为的干预的。
• 对同一份资源操作时,会存在资源抢夺的问题,需要加入并发控制;
• 线程会带来额外的开销,如cpu调度时间,并发控制开销。
• 每个线程在自己的工作内存交互,内存控制不当会造成数据不一致

02-线程创建

Thread, Runnable, Callable

1, 三种创建方式

• 继承Thread类
• 实现Runnable接口
• 实现Callable接口

2, 第一种:Thread

• 自定义线程类继承Thread类
• 重新run() 方法, 编写线程执行体
• 创建线程对象, 调用start() 方法启动线程

/**
 * 注意:  线程开启不一定立即执行, 由CPU调度执行
 */

//创建线程方式一: 继承Thread类, 重新run 方法, 调用start开启线程
public class TestThread1 extends Thread{
    @Override
    public void run() {
        //run 方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("run:"+i);
        }
    }
    //main线程,  主线程
    public static void main(String[] args) {
        //创建线程对象
        TestThread1 testThread1 = new TestThread1();
        //调用start 方法开启线程
        testThread1.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("main:"+i);
        }
    }
}

2.1 案例:下载图片

package com.ccc.lesson01;

import org.apache.commons.io.FileUtils;

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

//多线程同步下载图片
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() {
        WebDownLoad webDownLoad = new WebDownLoad();
        webDownLoad.download(url,name);
        System.out.println("下载图片名字为："+name);
    }

    public static void main(String[] args) {
        TestThread2 t1 = new TestThread2("https://https://www..com/sss1.png", "1.png");
        TestThread2 t2 = new TestThread2("https://www..com/sss2.png", "2.png");
        TestThread2 t3 = new TestThread2("https://www..com/sss3.png", "3.png");
        t1.start();
        t2.start();
        t3.start();
    }

}

class WebDownLoad{
    //下载方法
    public void  download(String url,String name){
        try {
            //使用工具包下载
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常,download方法异常");
        }
    }
}
//控制台   下载同时进行
下载图片名字为：2.png
下载图片名字为：1.png
下载图片名字为：3.png

3, 第二种:实现Runnable接口

• 定义MyRunnable类实现Runnable接口
• 实现run()方法, 编写线程执行提
• 创建线程对象, 调用start()方法启动线程
• 推荐使用 ! Java单继承模式

//方式2 , 实现Runnable接口
public class TestThread21 implements Runnable{
    @Override
    public void run() {
        //run 方法线程体
        for (int i = 0; i < 500; i++) {
            System.out.println("run:"+i);
        }
    }
    //main线程,  主线程
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        TestThread21 testThread21 = new TestThread21();
        //创建线程对象, 通过线程对象来开启线程-------代理
//        Thread thread = new Thread(testThread21);
//        thread.start();
        new Thread(testThread21).start();
        for (int i = 0; i < 20; i++) {
            System.out.println("main:"+i);
        }
    }
}

4, 第三种: 实现Callable接口(了解)

• 1,实现Callable接口,需要返回值类型
• 2,重写call方法,需要抛出异常
• 3.创建目标对象
• 4,创建执行服务: ExecutorService ser = Executors.newFixedThreadPool(1);
• 5,提交执行: Future result1 = ser.submit(1);
• 6,获取结果: boolean r1 = result1.get()
• 7,关闭服务: ser.shutdownNow();

package com.ccc.lesson02callable;

import com.ccc.lesson01.TestThread12;
import org.apache.commons.io.FileUtils;

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

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() throws Exception {
        WebDownLoad webDownLoad = new WebDownLoad();
        webDownLoad.download(url,name);
        System.out.println("下载图片名字为："+name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable t1 = new TestCallable("https://gi", "1.png");
        TestCallable t2 = new TestCallable("https://gi", "2.png");
        TestCallable t3 = new TestCallable("https://gi", "3.png");
        //创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(1);
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);
        //获取结果
        Boolean b1 = r1.get();
        Boolean b2 = r2.get();
        Boolean b3 = r3.get();
        //关闭服务
        ser.shutdownNow();

    }

}

class WebDownLoad{
    //下载方法
    public void  download(String url,String name){
        try {
            //使用工具包下载
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常,download方法异常");
        }
    }
}

5, 小结

• 继承Thread类
  • 子类继承Thread类具备多线程能力
  • 启动线程:子类对象.start()
  • 不建议使用:避免OOP单继承局限性

• 实现Runnable接口

  • 实现接口Runnable具有多线程能力
  • 启动线程:传入目标对象+Thread对象.start()
  • 推荐使用:避免单继承局限性,灵活方便. 方便同一个对象被多个线程使用

• 实现Callable接口

  • 可以定义返回值
  • //创建执行服务
    ExecutorService ser = Executors.newFixedThreadPool(1);
    Future r1 = ser.submit(t1);
    Future r2 = ser.submit(t2);
    Future r3 = ser.submit(t3);
    //获取结果
    Boolean b1 = r1.get();
    Boolean b2 = r2.get();
    Boolean b3 = r3.get();
    //关闭服务
    ser.shutdownNow();

//多线程同时操作同一个对象
//买火车票

//线程不安全
public class TestThread22 implements Runnable {
    //票数
    private int ticketNums = 10;

    @Override
    public void run() {
        while (true) {
            if (ticketNums<=0){
                break;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums--+"张");
        }
    }

    public static void main(String[] args) {
        TestThread22 tt = new TestThread22();
        new Thread(tt,"小明").start();
        new Thread(tt,"小红").start();
        new Thread(tt,"小绿").start();
    }
}

6 , 案例, 龟兔赛跑

1,首先来个賽道距离,然后要离终点越来越近
2,判断比赛是否结束
3.打印出胜利者
4,龟兔赛跑开始
5,故事中是乌龟赢的,兔子需要睡觉,所以我们来模拟兔子睡觉
6,终于,乌龟赢得比赛

import java.util.Random;

public class Race implements Runnable{
    //static保证只有一个, 共享  , final  不变
    private static  String winner;
    //兔子每次跑几步
    private int rabbit;
    //跑多少步
    private int count;
    private Random random =new Random();

    public Race(int rabbit, int count) {
        if (rabbit<=0){
            rabbit = 1;
        }
        this.rabbit = rabbit;
        this.count = count;
    }

    @Override
    public void run() {

        for (int i = 1; i <= count; i++) {
            //判断比赛是否结束
            boolean flag = gameOver(i);
            if (flag){
                break;
            }
            //兔子休息
            if (Thread.currentThread().getName().equals("兔子")){
                if ( random.nextInt()%5 ==1){
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //让兔子步数不超过总长度
                if ((count-i)<rabbit){
                    i+=count-i-1;
                }
                //兔子速率提高
                if ((count-i)>rabbit){
                    i+=rabbit-1;
                }
            }

            System.out.println(Thread.currentThread().getName()+"跑了几步:"+i);
        }
    }

    private boolean gameOver(int setps){
        //判断是否有胜利者
        if (winner!=null){
            return true;
        }
        if (setps >=count){
            winner = Thread.currentThread().getName();
            System.out.println("winner is" +winner);
            return true;
        }


        return false;
    }

    public static void main(String[] args) {
        //3:速度;兔子每次跑几步. 100:赛道长度
        Race race = new Race(3,100);
//        Race race = new Race(8000000,100000000);
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

03-静态代理

• 真实对象和代理对象都需要实现同一个接口
• 代理对象要代理真实角色
• 好处:
  • 代理对象可以做很多真实对象做不了的事情
  • 真实对象专注做自己的事情

package com.ccc.statiproxy;

public class StaticProxy {
    public static void main(String[] args) {
        //结婚对象
        You you = new You();
        //婚庆公司,  代理
        WeddingCompany weddingCompany = new WeddingCompany(you);
        //结婚
        weddingCompany.marry();
        //简化
        new WeddingCompany(new You()).marry();
        //启动线程
        new Thread( ()-> System.out.println("跑起来")).start();
    }
}

interface Marry{
    //结婚方法
    void marry();
}

class You implements Marry{
    @Override
    public void marry() {
        System.out.println("我结婚了");
    }
}
class WeddingCompany implements Marry{
    //代理人
    private Marry person;

    public WeddingCompany(Marry person) {
        this.person = person;
    }

    @Override
    public void marry() {
        before();
        //代理
        this.person.marry();
        after();
    }


    private void before() {
        System.out.println("结婚前活动");
    }

    private void after() {
        System.out.println("结婚后活动");
    }
}

04-Lamda表达式

• JDK 8 新增
• 入: 希腊字母表中排序第十一位的字母,英文名叫Lambda
• 避免匿名内部类定义过多
• 其实属于函数式编程的概念
• new Thread ( () -> {System.out.print("正义执行")}).start();

总结:

• 前提必须是函数式接口( 接口里面只能有一个抽象方法 )----------如:Runnable接口
• 有多个参数,需要使用括号,( int a,int b )–( a , b )
• 如果方法区,有多行代码,必须使用 代码块{花括号}

public class TestLambda01 {
    //内部类
    static class ClLike1 implements IfLike{
        @Override
        public void Like() {
            System.out.println("Lambda--内部类");
        }
    }
    public static void main(String[] args) {
        IfLike ifLike = null;
        //外部类
        ifLike = new ClLike();
        ifLike.Like();
        //内部类
        ifLike = new ClLike1();
        ifLike.Like();
        //局部内部类
        class ClLike2 implements IfLike{
            @Override
            public void Like() {
                System.out.println("Lambda--局部内部类");
            }
        }
        ifLike = new ClLike2();
        ifLike.Like();
        //匿名内部类
        IfLike ifLike2 = new IfLike() {
            @Override
            public void Like() {
                System.out.println("Lambda--匿名内部类");
            }
        };
        ifLike2.Like();
        //Lambda表达式   相当于简化了匿名内部类
        IfLike ifLike3 = ()->{
            System.out.println("Lambda--Lambda表达式");
        };
        ifLike3.Like();

        //如果Lambda表达式只有一行代码可以省略括号{}
        IfLike ifLike4 =() ->System.out.println("Lambda--Lambda表达式2");
        ifLike4.Like();

        //Lambda表达式,带参
        IfLike2 if2 = null;
        if2 = (int a,int b)->{
            System.out.println("Lambda--"+a+"-"+b);
        };
        if2.Like(520,502);
        //单参数可以省略括号()
        //if2 = a-> System.out.println("Lambda--"+a);

        //可以省略掉数据类型
        if2 = (a,b)-> System.out.println("Lambda--"+a+"-"+b);
        if2.Like(5200,5020);
    }

}
//函数式接口
interface IfLike{
    void Like();
}
interface IfLike2 {
    void Like(int a,int b);
}
class ClLike implements IfLike{
    @Override
    public void Like() {
        System.out.println("Lambda--");
    }
}

05-线程状态

创建, 就绪,阻塞,运行,死亡

1, 线程方法

2, 停止线程

• 不推荐使用JDK提供的stop() , destroy()方法 ( 已废弃 )
• 推荐线程自己停止下来
• 建议使用一个标志位进行终止变量, 如: 当flag=false, 就终止线程

package com.ccc.lesson05stop;
/**
 * 测试线程停止
 * 1 ,建议正常停止, 利用次数, 不建议死循环
 * 2. 建议使用标志位
 * 3,. 不要使用过时的方法: stop destroy 等 JDK不建议使用的方法
 */
public class TestStop implements Runnable {
    //1. 设置一个标志位
    private boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run"+i++);
        }

    }
    //2. 设置一个公开的方法停止线程, 转换标志位
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();
        for (int i = 0; i < 2000; i++) {
            System.out.println("main"+i);
            if (i==1900){
                testStop.stop();
                System.out.println("停止");
                break;
            }
        }
    }
}

3, 线程休眠

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

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.SimpleFormatter;
import java.util.zip.DataFormatException;

public class TestSleep {
    public static void main(String[] args) throws InterruptedException {
//            sleep();
    //获取系统时间
        while (true){
            Thread.sleep(1000);
            System.out.println(new SimpleDateFormat("HH:mm:ss")
                    .format(new Date(System.currentTimeMillis())));

        }
    }
    //模拟倒计时
    public static void sleep() throws InterruptedException {
        int num = 10;
        while (true) {
            Thread.sleep(1000);
            System.out.println(num--);
            if (num == 0) {
                break;
            }
        }
    }
}

4, 线程礼让(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()+"结束");
    }

5, Join

• Join合并线程, 待此线程执行完成后, 在执行其他线程, 其他线程阻塞
• 可以想象为插队

public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("VIP来了:"+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 < 500; i++) {
            if (i==200){
                thread.join();
            }
            System.out.println("主线程main:"+i);
        }
    }
}

6, 线程状态

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

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

  一个线程可以在给定时间点处于一个状态。 这些状态是不反映任何操作系统线程状态的虚拟机状态。

package com.ccc.lesson05join;

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();
        state = thread.getState();
        System.out.println(state);//RUNNABLE
        //TERMINATED 线程终止状态
        while (state != Thread.State.TERMINATED) {
            Thread.sleep(500);
            state = thread.getState();
            System.out.println(state);//TIMED_WAITING----TERMINATED
        }
    }
}

7, 线程优先级

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

• 线程的优先级用数字表示,范围从1-10. 10最高

  • Thread.MIN PRIORITY= 1;
  • Thread.MAX PRIORITY = 10;
  • Thread.NORM PRIORITY= 5;

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

  • getPriority(). setPriority(int xxx)

• 注意:

  • 优先级设定要在start(),启动之前设置
  • 优先级低只是意味着获得调度的概率低,并不是优先级低就不会调用了, 这都是看CPU的调度

package com.ccc.lesson05state;

public class TestPriority implements Runnable {


    public static void main(String[] args) {
        //获取main线程的优先级
        System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority());
        TestPriority testPriority = new TestPriority();
        Thread thread1 = new Thread(testPriority,"thread1");
        Thread thread2 = new Thread(testPriority,"thread2");
        Thread thread3 = new Thread(testPriority,"thread3");
        Thread thread4 = new Thread(testPriority,"thread4");
        Thread thread5 = new Thread(testPriority,"thread5");

        thread1.start();

        thread2.setPriority(9);
        thread2.start();

        thread3.setPriority(3);
        thread3.start();

        thread4.setPriority(10);
        thread4.start();

        thread5.setPriority(1);
        thread5.start();
        /*      结果
                main:5
                thread1:5
                thread3:3
                thread5:1
                thread4:10
                thread2:9
         */

    }





    @Override
    public void run() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority());
    }
}

8, 守护线程(Daemon)

• 线程分为用户线程和守护线程
• 虚拟机必须确保用户线程执行完毕
• 虚拟机不用等待守护线程执行完毕
• 如,后台记录操作日志,监控内存,垃圾回收等待…

    public static void main(String[] args) {
        Thread threadUser = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("用户线程" + i);
            }
        });
        Thread threadDaemon = new Thread(() -> {
            while (true){
                System.out.println("守护守护---");
            }
        });

        threadDaemon.setDaemon(true);
        threadUser.start();
        threadDaemon.start();//用户进程结束了,守护进程也随之结束
    }

06-线程同步

多个线程操作同一个线程

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

• 抢票
• 同时取钱
• 需要排队-队列

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

队列和锁

• 由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问
  冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制
  synchronized ,当一个线程获得对象的排它锁,独占资源,其他线程必须等待,
  使用后释放锁即可.存在以下问题:
• 一个线程持有锁会导致其他所有需要此锁的线程挂起;
• 在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题；
• 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置,引起性能问题

同步方法

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

  • synchronized方法和synchronized块.
  • 同步方法: public synchronized void method(int args) {}

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

• 缺陷:若将-个大的方法申明为synchronized将会影响效率

同步块

• Obj可以是任何对象,但是推荐使用共享资源作为同步监视器
• Obj 称之为同步监视器
  • ◆Obj可以是任何对象,但是推荐使用共享资源作为同步监视器
  • ◆同步方法中无需指定同步监视器,因为同步方法的同步监视器就是this ,就是这个对象本身, 或者是class [反射中讲解]
• ◆同步监视器的执行过程
• ◆同步块: synchronized (Obj){}
  ◆Obj 称之为同步监视器
  ◆Obj可以是任何对象,但是推荐使用共享资源作为同步监视器
  ◆同步方法中无需指定同步监视器,因为同步方法的同步监视器就是this ,就是
  这个对象本身, 或者是class [反射中讲解]
  ◆同步监视器的执行过程
  1. 第一个线程访问,锁定同步监视器,执行其中代码.
  2. 第二个线程访问 ,发现同步监视器被锁定,无法访问.
  3. 第一个线程访问完毕 ,解锁同步监视器.
  4. 第二个线程访问，发现同步监视器没有锁,然后锁定并访问

//买火车票
public class UnSafeBuyTicket extends Thread{
    private int ticket = 10;
    private boolean flag =true;

    @Override
    public void run() {
        while (flag) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            buy();
        }
    }
    //买票方法, synchronized 同步方法, 锁的是this
    public synchronized  void buy(){
        if (ticket<=0){
            flag=false;
            return;
        }

        System.out.println(Thread.currentThread().getName()+"买到了票"+ticket--);

    }
    public static void main(String[] args) {
        UnSafeBuyTicket tt = new UnSafeBuyTicket();
        new Thread(tt,"小红").start();
        new Thread(tt,"小明").start();
        new Thread(tt,"小白").start();
    }
}
_________________________________________________________________________________________

//银行取钱
public class UnSafeBanke {
    public static void main(String[] args) {
        Acount ac = new Acount("第一桶金", 100);
        Money m1 = new Money(ac, 100, "我");
        Money m2 = new Money(ac, 50, "你");
        m1.start();
        m2.start();
    }
}
//账户
class Acount{
     String name;
     int money;

    public Acount(String name, int money) {
        this.name = name;
        this.money = money;
    }
}

//取钱
class Money extends Thread{
    private int  drawNum;
    private String drawName;
    private int nowMoney;
    Acount acount;

    public Money(Acount acount, int drawNum, String name) {
        super(name);
        this.acount = acount;
        this.drawNum = drawNum;
    }

    //取钱
    @Override
    public void run() {
        //添加同步块    锁的对象是有变化的量
        synchronized(acount){
            if (acount.money-drawNum<0){
                System.out.println(Thread.currentThread().getName()+"钱不够");
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //卡里余额 = 余额- 取钱数
            acount.money -=drawNum;
            nowMoney +=drawNum;
            System.out.println(acount.name+"账户余额:"+acount.money);
            System.out.println(this.getName()+"取了:"+drawNum+"手里有:"+nowMoney);

        }
    }
}
___________________________________________________________________________________________
    
//list
public class UnSafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized(list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());

    }
}

JUC安全的list

public class TestJuc {
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
            Thread.sleep(1000);
            System.out.println(list.size());
    }
}

07-Lock(锁)

1, 死锁

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

死锁避免方法

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

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

• 把锁拿出来让对方可以拿到

2,Lock

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

synchronized与Lock的对比

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

08-线程协作

生产者消费者模式

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

线程通信

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

注意:

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

解决方式:

1. 管程法:生产者生产数据, 消费者负责处理数据, 缓冲区, 负责把生产者的数据放入缓冲区, 消费者再来拿
2. 信号灯:设置一个标志, 如果为真等待, 为假去唤醒

1,管程法

package com.ccc.lesson08cooperation;

public class TestPc {
    public static void main(String[] args) {
        SynContainer synContainer = new SynContainer();
        new Producer(synContainer).start();
        new Consumer(synContainer).start();
    }
}
//生产者
class Producer extends Thread{
    SynContainer syn ;

    public Producer(SynContainer syn) {
        this.syn = syn;
    }
    //生产   只负责生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            syn.pushChicken(new Chicken(i));
            System.out.println("生产了一只鸡,id:"+i);
        }
    }
}

//消费者
class Consumer extends Thread{
    SynContainer syn ;

    public Consumer(SynContainer syn) {
        this.syn = syn;
    }
    //消费. 只负责消费
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了一只鸡,id:"+syn.consumption().id);
        }
    }
}



//缓冲区
class SynContainer{
    Chicken[] chickens = new Chicken[10];
    int count=0;//计数器
    //生产者放入产品
    public synchronized void pushChicken(Chicken chicken)  {
        //如果容器满了,通知需要等待消费者来消费
        if (count==chickens.length){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满,我们就需要丢入产品
        chickens[count] = chicken;
        count++;


        //丢入产品后,有产品了可以通知消费者了
        this.notifyAll();

    }


    //消费者拿产品
    public synchronized Chicken consumption()  {
        //如果没有产品就等待,  等生产者生产
        if (count==0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //先减, 因为生产者生产第十只鸡后,count变成了10就等待了,这里消费减去再释放
        count--;
        Chicken chicken= chickens[count];
        //吃完以后释放
        this.notifyAll();
        return chicken;
    }

}


//产品
class Chicken{
    int id;//产品id

    public Chicken(int id) {
        this.id = id;
    }
}

2,信号灯

• 改造了缓冲区
• 建一个用一个

package com.ccc.lesson08cooperation;

public class TestPcFlag {
    public static void main(String[] args) {
        Restaurant synContainer = new Restaurant();
        new Producer(synContainer).start();
        new Consumer(synContainer).start();
    }
}
//生产者
class Producer extends Thread{
    Restaurant syn ;

    public Producer(Restaurant syn) {
        this.syn = syn;
    }
    //生产   只负责生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            syn.pushChicken(new Chicken(i));
            System.out.println("生产了一只鸡,id:"+i);
        }
    }
}

//消费者
class Consumer extends Thread{
    Restaurant syn ;

    public Consumer(Restaurant syn) {
        this.syn = syn;
    }
    //消费. 只负责消费
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了一只鸡,id:"+syn.consumption().id);
        }
    }
}



//餐厅
class Restaurant{
    //用于存放一只鸡
    Chicken chicken1 ;
    private  boolean flag = true;  //flag为true,没有鸡,生产者生产,消费者等候
    //生产者放入产品
    public synchronized void pushChicken(Chicken chicken)  {
        //有鸡了就等待
        if (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //没有鸡,生产一只
        chicken1 = chicken;
        flag=!flag;//变换状态
        this.notifyAll();

    }


    //消费者拿产品
    public synchronized Chicken consumption()  {
        //刚开始没有生产,  等生产者生产
        if (flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //有鸡就,吃一只
        Chicken chicken= chicken1;
        flag=!flag;//变换状态
        //吃完以后释放
        this.notifyAll();
        return chicken;

    }

}


//产品
class Chicken{
    int id;//产品id

    public Chicken(int id) {
        this.id = id;
    }
}

09-线程池

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

使用线程池

• JDK 5.0起提供了线程池相关API: ExecutorService和Executors
• ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor
  • void execute(Runnable command) :执行任务/命令,没有返回值,一般用来执行Runnable
  • Future submit(Callable task):执行任务,有返回值,一般又来执行Callable
  • void shutdown() :关闭连接池
• Executors:工具类、线程池的工厂类,用于创建并返回不同类型的线程池

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

//测试线程池
public class TestPool {
    public static void main(String[] args) {
        //1 创建服务, 设置线程池大小
        ExecutorService service = Executors.newFixedThreadPool(5);
        //2 执行     使用线程池中的线程执行
        service.execute(new MyThead());
        service.execute(new MyThead());
        service.execute(new MyThead());
        service.execute(new MyThead());
        service.execute(new MyThead());
        //3 关闭连接
        service.shutdown();
    }
}
class MyThead implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

10-总结

线程创建

1. 继承Thread类, 重写run方法
   1. 启动 new MyThread().start()
2. 实现Runnable接口, 重写run方法
   1. 启动: new Thread( new Mythread() ).start();
3. 实现Callable接口, 重写call方法,需要返回值
   1. 启动 FutureTask<obj> task = new FutureTask<obj>( new MyThread());
   2. new Thread ( task ).start();
   3. 获取返回值: task.get();

线程同步

1. synchronized 同步块
   1. synchronized (多线程操作的对象) {}
2. Lock (锁)
   1. 定义: ReentrantLock lock = new ReentrantLock();
   2. 使用: 加锁:lock.lock();,释放锁lock.unlock();