多线程学习

那我懂你的意思啦

已于 2022-09-12 16:47:33 修改

阅读量74

点赞数

文章标签：大数据

于 2022-07-11 16:52:22 首次发布

本文链接：https://blog.csdn.net/m0_61894608/article/details/125675814

版权

一、线程简介

1.多任务

一人同时做多项事情

2.多线程

加宽道路避免堵塞

3.程序、进程（Process）、线程(Thread)

一个进程可以有多个线程，如视频中同时听声音，看图像

二、线程创建

1.继承Thread类

（1）自定义线程类继承Thread类

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

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

package Thread;
//创建线程方式一：继承Thread类，重写run（）方法，调用start开启线程
public class TestThread1 extends Thread {
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码---"+i);
        }
    }
//两条线程同时交替执行
    public static void main(String[] args) {
        //main线程，主线程
        //创建一个线程对象
        TestThread1 testThread1=new TestThread1();
                //调用start()方法开启线程
        testThread1.start();//如果这里用run就正常顺序从上往下进行
        for (int i = 0; i < 2000; i++) {
            System.out.println("我在学习多线程--"+i);
        }
    }
}
//线程开启不一定立即执行，由CPU调度执行

运行结果：

2.网图下载

package Thread;

import java.io.File;
import java.net.MalformedURLException;
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(url:"图片路径"，name:"图片名字");
        t1.start();
    }
}
//下载器
class  WebDownloader{
    //下载方法
    public  void downloader(String url,String name){
        try {
            FileUtils.copyURLTOFile(new URL(url),new File(name));
        } catch (MalformedURLException e) {
            throw new RuntimeException(e);
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}//多个线程是同时执行的，谁先下完就是谁

3.实现Runnable接口（Java为单继承，推荐使用此放方法）

（1）定义MyRunnable类实现Runnable接口

（2）实现run（）方法，编写线程执行体

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

package Thread;
//创建线程方式2：实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法
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);
        }
    }
}

runnable与thread对比

4.初识并发问题

package Thread;

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

    @Override
    public void run() {
        while (true) {
            if (ticketNums <= 0) {
                break;
            }
            try {
                Thread.sleep(200);//模拟延迟
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            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();
    }

}

5.龟兔赛跑

package Thread;
//模拟龟兔赛跑
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(10);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            //判断比赛是否结束
            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,"兔子").start();
        new Thread(race,"乌龟").start();
    }
}

6.静态代理模式

package Thread;
//静态代理模式总结：
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色

//好处：
//代理对象可以做很多真实对象做不了的事情
//真实对象专注做自己的事情
public class StacticProxy {
    public static void main(String[] args) {

        WeddingCompany weddingCompany=new WeddingCompany(new You());
        weddingCompany.HappyMarry();
    }
}
interface Marry{

    void HappyMarry();
}
//真实角色，你去结婚
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("结婚了超开心");
    }
}
//代理角色，帮助你结婚
class WeddingCompany implements Marry{
   private Marry terget;

    public WeddingCompany(Marry target){
        this.terget=target;
    }
    @Override
    public void HappyMarry() {
        before();
        this.terget.HappyMarry();//这就是真实对象
        after();
    }
    private void before(){
        System.out.println("结婚之前，布置现场");
    }
    private void after(){
        System.out.println("结婚之后，收尾款");
    }

}

7.Lamda表达式

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

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

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

package lambda;

public class Testlambda1 {
    //3.静态内部类
    static class Like2 implements ILike{

        @Override
        public void lambda() {
            System.out.println("i like lambda2");
        }
    }

    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 lambda3");
            }
        }
like=new Like3();
     like.lambda();

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

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


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

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

package lambda;

public class Testlambda2 {
    public static void main(String[] args) {
        //1.lambda表示简化
        Ilove love=(int a)->{
            System.out.println("i love you-->"+a);
        };
        //简化1.参数类型
        love=(a)->{
            System.out.println("i love you-->"+a);
        };
        //简化2.简化括号
        love=a->{
            System.out.println("i love you-->"+a);
        };
        //简化3.去掉花括号
        love=a->System.out.println("i love you-->"+a);

        //总结
        //lambda表达式只有一行代码的请款下才能去掉花括号，如果有多行，就必须用代码块包裹（花括号）
        //前提是函数式接口
        //多个参数也可以去掉参数类型，要去掉都去，必须加上括号

        love.love(520);

    }
}
interface Ilove{
    void love(int a);
}

三、线程状态

1.线程停止

package state;
//测试stop
//1.建议线程正常停止--》利用次数，不建议使用死循环
//2.建议设置一个标志位
//3.不要使用stop或destory等JDK不推荐使用的方法
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.线程休眠 sleep

package state;

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

//模拟倒计时
public class TestSleep {
    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) {
                throw new RuntimeException(e);
            }
        }
    }
    //模拟倒计时
    public static void tenDown(){
        int num=10;

            try {
                while (true) {
                    Thread.sleep(1000);
                    System.out.println(num--);
                    if (num <= 0) {
                        break;
                    }
                }
            }catch (Exception e){
                e.printStackTrace();
            }

        }
    }

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

3.线程礼让 yield

让cpu重新调度，礼让不一定成功

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();
        Thread thread=new Thread(testJoin);
        thread.start();
        //主线程
        for (int i = 0; i < 1000; i++) {
            if (i==200){
                thread.join();//插队
            }
            System.out.println("main"+i);
        }
    }
}

5.线程状态观测

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(1000);
             } catch (InterruptedException e) {
                 throw new RuntimeException(e);
             }
             System.out.println("/");
         }
     });
     //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);
        //观察启动后
        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);//输出状态

        }
    }
}

6.线程的优先级

线程的优先级只是意味着获得调度的概率

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(4);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);//最大优先级为10，最小优先级为1
        t4.start();

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

7.守护线程

package state;

//测试守护线程
//上帝守护你
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();//上帝守护线程启动

        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 < 36500; i++) {
            System.out.println("你一生都开心的活着");

        }
        System.out.println("====goodbyeworld");
    }
}

四、线程同步

1.线程同步机制

队列：排队锁：让队列稳定排序

形成条件：队列+锁（安全性）

锁机制 synchronized

2.三大不安全案例

1.不安全买票

package syn;

//不安全的买票
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 {
                buy();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
    private void buy() throws InterruptedException {
        //判断是否有票
        if (ticketNums<=0){
            flag=false;
            return;
        }
        //模拟延时
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

2.不安全取钱

package syn;

//不安全取钱
//两个人去银行取钱，账户

public class UnsafeBank {
    public static void main(String[] args) {
        //账户
        Account account=new Account(100,"结婚基金");

        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;

    }
    //取钱

    @Override
    public void run() {
       //判断有没有钱
        if (account.money-drawingMoney<0){
            System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
            return;
        }
        //sleep可以放大问题的发生性
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        //卡内余额=余额-取得钱
        account.money=account.money-drawingMoney;
        //你手里的钱
        nowMoney=nowMoney+drawingMoney;
        System.out.println(account.name+"余额为："+account.money);
        System.out.println(this.getName()+"手里的钱"+nowMoney);
    }
}

3.线程不安全

package syn;

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(()->{
                list.add(Thread.currentThread().getName());
            }


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

4.同步方法及同步块

synchronized(在方法类型上加 public synchronized) 锁的对象就是变化的量

synchronized(锁的对象){} 同步块

5.死锁

package syn;
//解决死锁：一条资源每次只能被一个进程使用
//死锁：多个线程互相抱着对方需要的资源，形成僵持
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) {
            throw new RuntimeException(e);
        }
    }
    //化妆，互相持有对方的锁，就是需要拿到对方的资源

    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+"获得口红的锁");
            }
        }
    }


}

6.Lock锁

package syn;

import java.security.spec.PSSParameterSpec;
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) {
                    throw new RuntimeException(e);
                }
                System.out.println(ticketNums--);

            }else {
                break;
            }
        }finally {
            //解锁
            lock.unlock();

        }


    }
    }
}

五、线程协作

1.生产者消费者问题

1.管程法

package 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++) {
            try {
                container.push(new Chicken(i));
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            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) throws InterruptedException {
        //如果容器满了，就需要等待消费者消费
       if (count==chickens.length){
           //生产等待
           this.wait();
       }
        //如果没有满，就需要投入产品
        chickens[count]=chicken;
       count++;
       //可以通知消费者消费了
    }
    //消费者消费产品
    public synchronized Chicken pop(){
        //判断能否消费
       if (count==0){
           //等待生产者生产
       }
       //如果可以消费
        count--;
       Chicken chicken=chickens[count];
       //吃完了，，通知生产者生产
      return chicken;

    }
}

2.信号灯法

2.线程池

package gaoji;

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

//测试线程池
public class TestPool {
    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());

    }
}