JAVA多线程

欣欣今天敲代码了没

已于 2023-04-11 16:26:56 修改

阅读量49

点赞数

文章标签： servlet

于 2023-04-10 20:04:29 首次发布

本文链接：https://blog.csdn.net/m0_61909204/article/details/130008557

版权

本文详细介绍了Java中的线程创建，包括继承Thread、实现Runnable和Callable接口的方式，并展示了如何通过线程池执行任务。同时，讨论了线程的生命周期、阻塞模式以及线程安全问题。此外，还提到了静态代理和Lambda表达式的应用。

摘要由CSDN通过智能技术生成

线程：执行工作任务的最小执行单元

创建方式：（）面试解答

1.继承Thread：会分配内存空间，创建一个可以执行的线程

2.实现Runnable接口：不会分配内存创建具体线程只会实现任务接口没有任务返回结果

3.实现Callable接口：不会分配内存创建具体线程只会实现任务接口有返回结果

2.3会放到线程池借助线程执行

进程：最少包含一条线程（主线程）

线程生命周期:

new创建–>start就绪–>cpu调度（运行）–>sleep（阻塞）–>就绪

阻塞的三种模式：

Waiting:无休止的等待，再次启动需要其他线程唤醒它

Time-Waiting：带有时间参数的等待，自己唤醒

Blocking：自动等待资源

Mycallable:

package com.sunjob.s95rabc.多线程;

import java.util.Random;
import java.util.concurrent.Callable;

public class MyCallable implements Callable {
    @Override
//         Object 返回的值
    public Object call() throws Exception {
        System.out.println(Thread.currentThread().getName());
        return new Random().nextInt(9999);
    }
}

MyRunnable:

package com.sunjob.s95rabc.多线程;

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

myThread:

package com.sunjob.s95rabc.多线程;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author Milo
 * @date now
 */
public class MyThread  extends Thread
{

        @Override
    public void run() {
            //具体执行任务的入口
            System.out.println(Thread.currentThread().getName());

        }
}

创建测试：

package com.sunjob.s95rabc.多线程;

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

public class Process {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

//    myThread测试
//        main线程
        System.out.println(Thread.currentThread().getName());//main
       MyThread myThread=new MyThread();//jvm向内存申请空间 创建了一条线程
//        启动线程
        myThread.start();



//MyRunnable测试
        MyRunnable myRunnable=new MyRunnable();//没有start方法，不会自动创建线程
        new Thread(myRunnable).start();//借助一条其他线程运行


        //MyCallable测试
        MyCallable myCallable=new MyCallable();//没有start方法，不会自动创建线程
//        借助资源管理器运行
        FutureTask futureTask=new FutureTask(myCallable);//借助main线程运行
        futureTask.run();//线程执行返回结果
        int s = (int)futureTask.get();
        System.out.println(s);

    }
}

运行结果：

【【狂神说Java】多线程详解】 https://www.bilibili.com/video/BV1V4411p7EF/?share_source=copy_web&vd_source=e83c56120f8e705dacde5a87c1bb375c

狂神说多线程笔记整理_狂神多线程笔记_dorisPotter的博客-CSDN博客

start交替执行

public class Demo3_CreateRunnable implements Runnable {

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

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        Demo3_CreateRunnable testThread = new Demo3_CreateRunnable();
        //创建线程对象,通过线程对象来开启我们的线程,代理
        Thread thread = new Thread(testThread);
        //调用start（）开启线程
        thread.start();

        //new Thread(testThread).start();
        for (int i = 0; i < 200; i++) {
            System.out.println("我在学习多线程----" + i);
        }
    }
}

/**
 * 多个线程同时操作同一个对象  买火车票案例
 */
//发现问题:多个线程操作同一个资源的情况下,线程不安全,数据紊乱
public class Demo4_TrainTicketsCase 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) {
        Demo4_TrainTicketsCase ticket = new Demo4_TrainTicketsCase();
        new Thread(ticket, "小红").start();
        new Thread(ticket, "老师").start();
        new Thread(ticket, "黄牛1").start();
        new Thread(ticket, "黄牛2").start();
    }
}

龟兔赛跑：

/**
 * 模拟龟兔赛跑
 */
public class Demo5_RaceCase 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(2);
                } 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;
        } else {
            if (steps >= 100) {
                winner = Thread.currentThread().getName();
                System.out.println("winner is " + winner);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Demo5_RaceCase race = new Demo5_RaceCase();
        new Thread(race, "兔子").start();
        new Thread(race, "乌龟").start();
    }
}

/**
 * 实现Callable接口
 */
public class Demo6_CreateCallable implements Callable<Boolean> {

    private String url;//网络图片地址
    private String name;//报错扥文件名

    //有参构造
    public Demo6_CreateCallable(String url, String name) {
        this.url = url;
        this.name = name;
    }

    //下载图片线程的执行体
    public Boolean call() throws Exception {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url, name);
        System.out.println("下载了文件名为:" + name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Demo6_CreateCallable c = new Demo6_CreateCallable("https://img-home.csdnimg.cn/images/20201124032511.png", "1.png");
        Demo6_CreateCallable c1 = new Demo6_CreateCallable("https://img-home.csdnimg.cn/images/20201124032511.png", "2.png");
        Demo6_CreateCallable c2 = new Demo6_CreateCallable("https://img-home.csdnimg.cn/images/20201124032511.png", "3.png");
        //创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> r = ser.submit(c);
        Future<Boolean> r1 = ser.submit(c1);
        Future<Boolean> r2 = ser.submit(c2);
        //获取结果
        boolean res = r.get();
        boolean res1 = r1.get();
        boolean res2 = r2.get();
        //关闭服务
        ser.shutdownNow();
    }
}
//class WebDownloader在前面下载图片已经定义了，这里就不用再次写，直接使用就好

静态代理：

/**
 * 静态代理:结婚案例
 */
public class Demo7_StaticProxy {
    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("doris要结婚了,超开心");
    }
}

//代理角色:帮助你结婚
class WeddingCompany implements Marry {
    private Marry target;//代理-->真实目标角色角色,帮谁结婚

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

    @Override
    public void happyMarry() {
        after();
        this.target.happyMarry();
        before();
    }

    private void after() {
        System.out.println("结婚之前,布置现场");
    }

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

总结

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

好处

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

静态内部类：

局部内部类：

匿名内部类：

lambda：

public class Demo14_LamdaCase2 {
    public static void main(String[] args) {
        // 1.lamda
        ILove love = (int a) -> {
            System.out.println("I love you -->" + a);
        };
        // 2.lamda简化1.0
        love = (a) -> {
            System.out.println("I love you -->" + a);
        };
        // 3.lamda简化2.0
        love = a -> {
            System.out.println("I love you -->" + a);
        };
        // 3.lamda简化3.0
        love = a -> System.out.println("I love you -->" + a);

        /**总结:
         * {}简略的条件是只能有一行代码,多行{}就不能简略了
         * 前提是接口为函数式接口(只能有一个方法)
         * 多个参数也可以去掉参数类型,要去掉就都去掉,必须加上()
         */

        love.love(520);
    }
}

interface ILove {
    void love(int a);
}

/**
 * 测试stop
 * 1.建议线程正常停止-->利用次数,不建议死循环
 * 2.建议使用标志位-->设置一个标志位
 * 3.不要使用stop或者destroy等过时或者JDK不建议使用的方法
 */
public class Demo15_StopThread 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) {
        Demo15_StopThread stop = new Demo15_StopThread();
        new Thread(stop).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main..." + i);
            if (i == 900) {
                //调用stop()切换标志位,让线程终止
                stop.stop();
                System.out.println("该线程停止了");
            }
        }
    }
}