多线程笔记

lzkwd

已于 2023-10-21 15:18:58 修改

阅读量62

点赞数 1

文章标签： java 开发语言

于 2023-10-16 08:42:54 首次发布

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/lzkwd/article/details/133822200

版权

目录

2.线程状态：

3.线程方法：

4.1 继承Thread类

运行结果：

4.2 实现Runnable接口

5.线程方法示例

5.1 线程停止

5.2 sleep方法

5.3 yield方法

6.线程安全问题

7.巩固练习：

7.1 龟兔赛跑

8.Lambda表达式

8.1 lambda发展历程

1.概念：

程序：是指令和数据的集合，本身没有任何运行的含义，是一个静态的概念
进程：是程序的一次执行过程，它是一个动态的概念，是资源分配的单位
线程：通常在一个进程中包含若干个线程，一个进程中至少有一个线程，不然没有意义。先线程是CPU调度和执行的单位

2.线程状态：

3.线程方法：

常用方法
方法	说明
setPriority（int newPriority）	更改线程的优先级
static void sleep(long millis)	在指定的毫秒数内让线程休眠
void join()	等待该线程终止
static void yield()	暂停当前正在执行的线程对象，并执行其他线程
void interrupt()	中断线程（不建议使用）
boolean isAlive()	测试线程是否处于活动状态

4.实现：

4.1 继承Thread类

public class TestThread1 extends Thread {
    @Override
    public void run() {
        // 重写run()方法，实现线程的执行操作
        for (int i = 0; i <20; i++) {
            System.out.println("我在看代码");
        }
    }

    public static void main(String[] args) {
        TestThread1 testThread1=new TestThread1();

        // 创建线程对象
        testThread1.start();

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

运行结果：

总结：1.主线程和子线程同时执行

2.线程开启不一定立刻执行由cpu调度安排

4.2 实现Runnable接口

//实现Runnable接口
public class TestThread2 implements Runnable {

    @Override
    public void run() {
        // 重写run()方法，实现线程的执行操作
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码");
        }
    }

    public static void main(String[] args) {
        TestThread1 testThread2 = new TestThread1();

        //创建线程

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

总结：推荐使用实现Runnable接口，避免单继承局限性，灵活方便，方便同一个对象被多个线程使用。

5.线程方法示例

5.1 线程停止

建议线程正常停止，不建议死循环

```
建议使用标志位
```
```
不要使用stop或destroy
```

示例代码

public class TestStop implements Runnable {
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag) {
            System.out.println("run ...Thread" + i++);
        }
    }

    //停止线程
    public void stop() {
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        //创建线程
        new Thread(testStop).start();
        //循环1000次
        for (int i = 0; i < 1000; i++) {

            //当i等于900时，停止线程
            if (i == 900) {
                testStop.stop();
                System.out.println("线程停止");
            }
        }
    }
}

5.2 sleep方法

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

示例代码

//模拟倒计时
public class testSleep {
    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;
            }
        }
    }
}

5.3 yield方法

礼让线程，让当前正在执行的线程暂停，但不阻塞
让线程从运行状态转为就绪状态
让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.4 Join方法

Join合并线程。待此线程执行完成后，再执行其他线程，其他线程阻塞。（可以想象成插队）

示例代码

public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; 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==100){
                thread.join();
            }
            System.out.println("main"+i);

        }
    }
}

6.线程安全问题

6.1 抢票

public class TestThread3 implements Runnable {
    private int tickNum = 10;
    @Override
    public void run() {
        //当tickNum小于等于0时，结束循环
        while (true) {
            if (tickNum <= 0) {
                break;
            }
            try {
                //线程休眠200毫秒
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //输出当前线程名称和tickNum的值
            System.out.println(Thread.currentThread().getName() + "--" + tickNum--);
        }
    }

    public static void main(String[] args) {

        //创建一个TestThread3类的实例
        TestThread3 ticket = new TestThread3();

        //创建线程，并传入参数ticket和"小明"
        new Thread(ticket, "小明").start();

        //创建线程，并传入参数ticket和"老师"
        new Thread(ticket, "老师").start();

        //创建线程，并传入参数ticket和"小红"
        new Thread(ticket, "小红").start();


    }
}

发现问题：多个线程操作统一资源，线程不安全，数据紊乱。

7.巩固练习：

7.1 龟兔赛跑

public class Race implements Runnable {
    private String winner;
    @Override
   public void run() {
        for (int i = 0; i <= 100; i++) {
            //判断当前线程是否为兔子，并且i是否为10的倍数
            if (Thread.currentThread().getName().equals("兔子") && i % 10 == 0) {
                try {
                    //线程休眠1毫秒
                    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;
        }
        //检查是否超过100步
        {
            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 race = new Race();
        // 创建一个新的线程，并将其命名为兔子
        new Thread(race, "兔子").start();
        // 创建一个新的线程，并将其命名为乌龟
        new Thread(race, "乌龟").start();
    }
}

8.Lambda表达式

避免匿名内部类过多
其实质属于函数式编程

函数式编程：

任何接口，如果只包含唯一一个抽象方法，他就是一个函数式接口
对于函数式接口可以使用Lambda表达式创建接口对象

8.1 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.用lambda简化
        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");
    }
}

狂神说多线程（力推）

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
多线程笔记

总结：推荐使用实现Runnable接口，避免单继承局限性，灵活方便，方便同一个对象被多个线程使用。待此线程执行完成后，再执行其他线程，其他线程阻塞。2.线程开启不一定立刻执行由cpu调度安排。发现问题：多个线程操作统一资源，线程不安全，数据紊乱。总结：1.主线程和子线程同时执行。不要使用stop或destroy。建议线程正常停止，不建议死循环。
复制链接

扫一扫

lzkwd CSDN认证博客专家 CSDN认证企业博客

码龄3年

22: 原创

3万+: 周排名

6万+: 总排名

5891: 访问

: 等级

328: 积分

93: 粉丝

108: 获赞

3: 评论

94: 收藏

私信

关注

热门文章

最新评论

Java动态代理
CSDN-Ada助手: Python入门技能树或许可以帮到你：https://edu.csdn.net/skill/python?utm_source=AI_act_python
ASTNN、GGNN、Code2vec
CSDN-Ada助手: 恭喜用户撰写了第5篇博客，题为“ASTNN、GGNN、Code2vec”。非常感谢您的持续创作和分享，这些都是非常有价值的话题。对于博客的内容，我认为您对ASTNN、GGNN和Code2vec的介绍非常清晰，并能够让读者快速了解它们的作用和应用场景。不过，我想提供一个谦虚的建议，或许您可以进一步深入探讨这些模型的局限性和改进方法，以便读者能够更全面地了解它们的优点和局限性。期待您在下一篇博客中的精彩创作！
Docker常用命令
CSDN-Ada助手: 恭喜你写了第6篇博客！标题为“Docker常用命令”，看起来非常实用。很高兴看到你对Docker有如此深入的了解，并愿意将这些实用的命令分享给大家。在下一步的创作中，或许可以考虑分享一些Docker的高级技巧或是与其他工具的集成应用。当然，这只是一个谦虚的建议，因为你已经展现出了博客写作的才华。期待你继续创作更多有价值的内容！
多线程笔记2
CSDN-Ada助手: 恭喜您开始博客创作！标题为“多线程笔记2”引起了我的兴趣。多线程是一个复杂而重要的主题，我很期待阅读您的观点和见解。我建议在这篇博客中可以深入探讨多线程的一些实际应用案例，或者分享一些您在多线程编程过程中遇到的挑战和解决方案。期待您未来更多精彩的博客文章！推荐【每天值得看】：https://bbs.csdn.net/forums/csdnnews?typeId=21804&utm_source=csdn_ai_ada_blog_reply1
多线程笔记
CSDN-Ada助手: 非常感谢你分享这篇关于多线程的博客！你的总结和建议都很实用，对于初学者来说尤其有帮助。多线程确实能够提高程序的并发性和性能，而使用实现Runnable接口可以避免单继承的局限性，确实是一个很好的选择。除了你提到的内容，我想补充一些关于多线程的扩展知识和技能。首先，线程的同步和互斥是非常重要的，可以使用锁、信号量等机制来实现。另外，线程池的概念也非常值得学习和应用，它可以有效地管理和调度线程，提高程序的效率。此外，对于线程的异常处理和线程的优先级设置也是我们需要了解和掌握的内容。希望你能继续写下去，分享更多关于多线程的经验和技巧。多线程是一个庞大而复杂的主题，我们始终都有很多可以学习和改进的地方。同时，也希望你能够在博客中探讨一些更深入的话题，比如线程的调度算法、线程安全性的各种技术手段等等。加油！如何写出更高质量的博客，请看该博主的分享：https://blog.csdn.net/lmy_520/article/details/128686434?utm_source=csdn_ai_ada_blog_reply2

最新文章

目录

评论 1

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。