多线程笔记

狂神多线程

https://www.bilibili.com/video/BV1V4411p7EF?

多线程概念

线程创建

创建一个线程的两种方法：1.将一个类声明为Thread的子类

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

2.重写run（）方法，编写线程执行体

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

package Theread.demo1;
//创建线程方式一：继承Thread类
//注意：线程开启不一定立即执行，又CPU调度执行
public class TestThread1  extends Thread{
    public void run(){
        for (int i = 0; i < 200; i++) {
            System.out.println("我在敲代码--"+i);
        }
    }

    public static void main(String[] args) {
        //main 线程，主线程

        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();

        //调用start()方法开启线程
        testThread1.start();

        //调用start（)方法开启线程
        testThread1.run();
        for (int i = 0; i < 1000; i++) {
            System.out.println("我在学习多线程--"+i);
        }
    }
}

package Theread.demo1;
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("","1.jpg");
        TestThread2 t2=new TestThread2("","1.jpg");
        TestThread2 t3=new TestThread2("","1.jpg");

        t1.start();
        t2.start();
        t3.start();

    }
}

class WebDownloader{
    public void downloader(String url,String name){
        try {
            FileUtils.copyURLToFile(new URL(url),new File(neme));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，Downloader方法异常");
        }
    }
}

实现Runnable接口

1.定义MyRunnable类实现Runnable接口

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

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

package Theread.demo1;

public class TestThread3 implements Runnable{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 200; i++) {
            System.out.println("我在写代码----"+i);
        }
    }

    public static void main(String[] args) {
        //创建runnable接口实现类对象
        TestThread3 testThread3 =new TestThread3();

        //创建线程对象，通过线程对象来开启线程，代理
//        Thread thread= new Thread(testThread3);
//
//        thread.start();
        new Thread(testThread3).start();


        for (int i = 0; i < 1000; i++) {
            System.out.println("我在学习多线程--"+i);
        }
    }
}

package Theread.demo1;
//多个线程同时操作同一个对象的情况下，线程不安全
//买火车票的例子
public class TestThread4 implements Runnable {
    private int ticketNums=10;

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

            if(ticketNums<=0){
                break;
            }
            //模拟延时 Thread.sleep()
            try {
                Thread.sleep(200);
            } 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,"小1").start();
        new Thread(ticket,"小2").start();

    }
}

package Theread.demo1;
//模拟龟兔赛跑
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("tuzi")&& 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 steps){
//        判断是否有胜利者
        if (winner!=null){  //已经存在胜利者
            return true;
        }{
            if (steps>=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,"tuzi").start();
        new Thread(race,"wugui").start();
    }


}

静态代理

//静态代理模式：
//真实对象和代理对象都要实现同一个接口
//代理对象必须要代理真实角色：代理对象能做好多真实对象做不了的事
public class StaticProxy {
    public static void main(String[] args) {

        new Thread(()-> System.out.println("我恨你")).start();
        new WeddingCompany(new You()).HappyMarry();
    }



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

}
//真实对象
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("千年等一回");
    }
}
//代理对象
class WeddingCompany implements Marry{
//代理谁--》真实目标角色
    private Marry target;  //把target传入Marry

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

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();//这是真实对象调用
        after();

    }
    public  void after(){
        System.out.println("结婚之后收尾款");
    }
    public void before(){

        System.out.println("结婚前布置");
    }
}

package Lambda;
/*
推导lambda表达式
* */
public class TestLambda {

//    3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println(" i like lambda");
        }
    }
    public static void main(String[] args) {
        ILike like =new Like();
        like.lambda();

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


//        4.局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println(" i like lambda2");
            }
        }
        like =new Like3();
        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");
        };
        like.lambda();



    }
}
//1.定义一个函数式接口
interface ILike{
     void lambda();
}
//2.实现类
class  Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("lambda");
    }
}

package Lambda;

public class TestLambda2 {


    public static void main(String[] args) {
        //1.lambda表示简化
        ILove love= (int a,int b) -> {
            System.out.println("i love you -->"+a);
        };

        //2.简化类型：参数类型
        love = (a,b)->{
            System.out.println("you");
            System.out.println("i"+a);
        };
        //3.简化：去掉花括号
        love=(a,b)-> System.out.println("i you "+a);

//总结：lambda表达式只有一行代码的情况下才能够简化成一行，如果有多行代码，那么就用代码块包裹。
        //前提是接口为函数式接口
//        多个参数也可以去掉参数类型，要去掉都去掉，必须加括号


         love.love(2,6);
    }

}

//1.定义一个带参函数式接口
interface  ILove{
    void love(int a,int b);

}

线程状态

五大状态：创建状态，就绪状态 ，阻塞状态，运行状态，死亡状态

1.停止线程

package state;
//测试stop
//1.建议线程正常停止--》利用次数，不建议死循环
//2.建议使用标志位：flag
//3.不要使用stop、destroy等过时或者JDK5不建议 使用的方法
public class TestStop implements Runnable{
    //1.设置一个标志位
    private  boolean  flag =true;

    @Override
    public void run() {
        int i =0;
        while(flag){
            System.out.println("run.....Thread"+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 < 1000; i++) {
            System.out.println("main"+i);
            if (i==900){
                //调用stop方法切换标志位，让线程停止
                testStop.stop();
                System.out.println("线程停止");
            }
        }
    }
}

2.线程休眠

package state;

import Theread.demo1.TestThread4;
//模拟网络延时
public class TestSleep implements Runnable{
//    票数
        private int ticketNums=10;

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

                if(ticketNums<=0){
                    break;
                }
                //模拟延时 Thread.sleep()
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName()+
                        "拿到了第" +ticketNums--+"票");

            }

        }

        public static void main(String[] args) {
            Theread.demo1.TestThread4 ticket = new Theread.demo1.TestThread4();

            new Thread(ticket,"小明").start();
            new Thread(ticket,"小1").start();
            new Thread(ticket,"小2").start();

        }
}

package state;

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

//模拟倒计时
public class TestSleep2 {
    public static void main(String[] args) {
        //打印当前系统的时间
        Date startDate = new Date(System.currentTimeMillis());//获取当前时间

        while (true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startDate));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

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

3.线程礼让

package state;
//测试线程礼让
//礼让不一定成功，看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

package state;
//测试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();
        new Thread(testJoin).start();

        //启动主线程
        for (int i = 0; i < 100; i++) {
            if (i==2000){
                new Thread(testJoin).join();;//插队
            }
            System.out.println("main"+i);
        }
    }
}

线程状态观测

package state;
//观察线程状态
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(200);
                } 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);//run

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

线程优先级

package state;
//测试线程的优先级
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);
        Thread t2 =new Thread(myPriority);
        Thread t3 =new Thread(myPriority);
        Thread t4 =new Thread(myPriority);
        Thread t5 =new Thread(myPriority);
        Thread t6 =new Thread(myPriority);
//设置优先级，在启动
        t1.start();
        t2.setPriority(1);
        t2.start();

        t3.setPriority(3);
        t3.start();

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

        t5.setPriority(6);
        t5.start();

        t6.setPriority(2);
        t6.start();
    }
}

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

守护线程

package state;
//测试守护线程
//上帝守护你

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

        new Thread(god).setDaemon(true);//默认是false表示是用户线程，正常的线程都是用户线程。。。。
        new Thread(god).start();//上帝守护线程
        new Thread(you).start();//你 用户线程启动
    }
}

class God implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("上帝保佑你");
        }
    }
}

class You implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 365000; i++) {
            System.out.println("活到一千岁");
        }
        System.out.println("====goodbye,world");
    }
}

线程同步机制

多个线程操作同一个资源

三大不安全案例

package 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 numTicket=10;
    boolean flag =true;//外部停止方式

    @Override
    public void run() {
        //买票
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
//synchronized 同步方法，锁的是this
    private synchronized void buy() throws InterruptedException {
//        判断是否有票
        if (numTicket<=0){
            flag=false;
            return;
        }
        //模拟延时
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+numTicket);
    }
}

package Synchronized;
//银行取钱：多人
public class UnSafeBank {
    public static void main(String[] args) {
        Account account = new Account(1000,"基金");

        Drawing you =new Drawing(account,50,"ni");
        Drawing wife =new Drawing(account,60,"ta");

        you.start();
        wife.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;


    }
    //取钱
//    synchronized 默认锁的是this
    @Override
    public  void run() {
//锁的对象就是变化的量，需要增删改的对象
        synchronized (account){
            if (account.money-drawingMoney<0){
                System.out.println(Thread.currentThread().getName()+"钱不够了,取不了了");
                return;
            }
            //sleep可以方法问题的发生性
//        try {
//            Thread.sleep(200);
//        } 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);
        }


    }
}

package Synchronized;

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 < 1000; i++) {
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

CopyOnWriteArrayList

package Synchronized;

import java.util.concurrent.CopyOnWriteArrayList;
//测试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(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

死锁

package Theread;
//死锁：多个线程相互抱着对方需要的资源，然后形成僵持
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 + "获得口红的锁");
            }
        }
    }
}

锁

ReentrantLock类实现了lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

package Theread;

import java.util.concurrent.locks.ReentrantLock;

//测试锁
public class TestLock {
    public static void main(String[] args) {
        TestLock1 testLock1 =new TestLock1();

        new Thread(testLock1).start();
        new Thread(testLock1).start();
        new Thread(testLock1).start();
    }
}

class TestLock1 implements Runnable{
    int num=10;

    //定义lock锁
    private final ReentrantLock lock =new ReentrantLock();
    @Override
    public void run() {
        while(true){
            try{
                //加锁
                lock.lock();
                if (num>0){
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(num--);
                }else{
                    break;
                }
            }finally {
                //解锁
                lock.unlock();
            }


        }
    }
}

线程协作

​

package Theread;
//测试：生产者消费者模型--》利用缓冲区解决：管程法
//生产者，消费者，产品，缓冲区
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++) {
            System.out.println("生产了"+i+"只鸡");
            container.push(new Chicken(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++;
        //通知消费者消费
        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;
    }

}

线程池

package Theread;

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

/**
 * @author by 星爷
 * @classname   TestThreadPool
 * @description  测试线程池
 * @date 2021-09-15 20:25
 */
public class TestThreadPool {
    public static void main(String[] args) {
//1.创建服务，创建线程池
//        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());
    }
}

总结

package Theread;

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

/**
 * @author by 星爷
 * @classname   ThreadNew
 * @description  创建线程的总结
 * @date 2021-09-15 20:38
 */
public class ThreadNew {
    public static void main(String[] args) {
        new MyThread1().start();

        new Thread(new MyThread2()).start();

        FutureTask futureTask =new FutureTask(new MyThread3());
        new Thread(futureTask).start();
        try {
            Integer integer= (Integer) futureTask.get();
            System.out.println(integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}

class MyThread1 extends Thread{
    @Override
    public void run() {
        System.out.println("第一种");
    }
}

class MyThread2 implements Runnable{
    @Override
    public void run() {
        System.out.println("最重要的");
    }
}

class MyThread3 implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("了解即可");
        return 100;
    }
}

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

/**

• @author by 星爷

• @classname ThreadNew

• @description 创建线程的总结

• @date 2021-09-15 20:38
  */
  public class ThreadNew {
  public static void main(String[] args) {
  new MyThread1().start();

   new Thread(new MyThread2()).start();
  
   FutureTask futureTask =new FutureTask(new MyThread3());
   new Thread(futureTask).start();
   try {
       Integer integer= (Integer) futureTask.get();
       System.out.println(integer);
   } catch (InterruptedException e) {
       e.printStackTrace();
   } catch (ExecutionException e) {
       e.printStackTrace();
   }
  

  }

}

class MyThread1 extends Thread{
@Override
public void run() {
System.out.println(“第一种”);
}
}

class MyThread2 implements Runnable{
@Override
public void run() {
System.out.println(“最重要的”);
}
}

class MyThread3 implements Callable{
@Override
public Integer call() throws Exception {
System.out.println(“了解即可”);
return 100;
}
}