javase-thread-210312-01

最新推荐文章于 2024-09-25 10:59:43 发布
最新推荐文章于 2024-09-25 10:59:43 发布
阅读量71 收藏
点赞数
分类专栏： javase 文章标签： java thread javase 多线程
白光一
本文链接：https://blog.csdn.net/FlyUp__/article/details/118378412
版权

javase-thread-210312-01

  • Lamda表达式
  • 线程状态
    • 线程停止 线程休眠 线程暂停
    • 线程强制执行 线程状态 线程优先级 守护线程

Lamda表达式

可以避免匿名内部类定义过多
可以让代码看起来更简洁
去掉了一些没有意义的代码，只留下核心的逻辑

Lamda表达式的使用必须是一种函数式接口（Functional Interface），，
Java8才有Lamda表达式

函数式接口的定义：
	任何接口，，接口中只包含唯一的一个抽象方法，（只有一个抽象的方法的接口称为函数式接口）
	对于函数式接口，我们可以通过Lamda表达式来创建该接口的对象
Demo01
public class DemoLamda01 {

     // 2.方式二   静态内部类
    static class ILike02 implements Like{
         @Override
         public void lamda() {
             System.out.println("I like you！！！----静态内部类");
         }
     }

    public static void main(String[] args) {

        // 方式一   实现接口
        Like like = new ILike01();
        like.lamda();

        // 方式二   静态内部类
        like = new ILike02();
        like.lamda();


        // 3.方式三    局部内部类
        class ILike03 implements Like{
            @Override
            public void lamda() {
                System.out.println("I like you！！！----局部内部类");
            }
        }
        like = new ILike03();
        like.lamda();

        // 4.方式四    匿名内部类,,没有类名,,必须依靠父类或者是接口
        like = new Like() {
            @Override
            public void lamda() {
                System.out.println("I like you！！！----匿名内部类");
            }
        };
        like.lamda();

        // 5.方式五    lamda表达式
        like = () -> {
            System.out.println("I like you！！！----lamda表达式");
        };
        like.lamda();

    }
}


// 定义一个函数式接口（只有唯一的一个抽象方法）
interface Like{
    void lamda();
}


// 1.方式一    实现接口
class ILike01 implements Like{
    @Override
    public void lamda() {
        System.out.println("I like you！！！----实现接口方式");
    }
}
Demo02
package bgy01_lamda;

/**
 注意：
    1.  lamda表达式只能有一行代码的情况下才能简化为一行（简化3），，，如有多行，必须加上花括号
    2.  使用lamada表达式的前提，接口为函数式接口（接口中只有一个抽象方法）
    3.  多个参数的也可以去掉参数类型，要去都去掉，，，必须加上括号
 */

public class DemoLamda02 {
    public static void main(String[] args) {
        Love love = null;
        Love01 love01 = null;
        Love02 love02 = null;

        // 简化1，，阐述类型
        love = (a) -> {
            System.out.println("哈哈哈哈哈"+a);
        };
        love01 = (a,b) -> {
            System.out.println(a + "+" + b + "=" + (a+b));
        };
        love02 = (int a,int b,int c) -> {
            System.out.println(a + "+" + b + "+" +c + "=" + (a+b+c));
        };
        love.iLove(999);
        love01.iLove(1,2);
        love02.iLove(1,2,3);


        // 简化2，，简化括号
        love = a -> {
            System.out.println("哈哈哈哈哈"+a);
        };
        love.iLove(888);

        // 简化3，，去掉花括号
        love = a -> System.out.println("哈哈哈哈哈"+a);
        love.iLove(777);
    }
}

interface Love{
    void iLove(int a);
}

interface Love01{
    void iLove(int a,int b);
}

interface Love02{
    void iLove(int a,int b,int c);
}

线程状态

  • 创建状态
  • 就绪状态
  • 阻塞状态
  • 运行状态
  • 死亡状态
线程停止
package bgy02;

/*
	JDK 提供的方法都过时了，，，还是自己定义的比较好
*/

public class Demo01_ThreadStop implements Runnable{

    // 设置表示符
    private boolean flag = true;

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

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

    public static void main(String[] args) {
        Demo01_ThreadStop demo = new Demo01_ThreadStop();
        new Thread(demo,"会停止线程").start();

        for (int i = 0; i < 150; i++) {
            System.out.println(Thread.currentThread().getName()+" is run....."+i);
            if(i == 100){
                
                // 调用stop方法，让线程停止
                demo.stop();        // 让   “会停止线程”   这个线程停止
                System.out.println("线程停止");
            }
        }
    }
}
线程休眠
1000毫秒=1秒

sleep()	方法，让线程休眠，，（毫秒）
	阻塞当前线程
	存在异常，，InterruptedException
	到达时间后线程进入就绪状态
	每一个对象都有一把锁，，，sleep方法不会释放锁

sleep方法可以模拟网络延时，倒计时等。。。
倒计时
public class Demo02_ThreadSleep01 implements Runnable{
    @Override
    public void run() {
        try {
            daoJiShi();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void daoJiShi() throws InterruptedException {
        int num = 10;
        while (true){
            Thread.sleep(1000);
            System.out.println("倒计时："+num--);

            if(num < 0){
                break;
            }
        }
    }

    public static void main(String[] args) {
//        try {
//            daoJiShi();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }

        Demo02_ThreadSleep01 demo=new Demo02_ThreadSleep01();
        new Thread(demo).start();
    }
}
获取当前时间
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo02_ThreadSleep02 implements Runnable{
    @Override
    public void run() {

    }

    public static void main(String[] args) {
        Date date = new Date(System.currentTimeMillis());   // 获取当前时间

        while (true){
            try {
                Thread.sleep(1000);
                System.out.println("当前时间为：" + new SimpleDateFormat("HH:mm:ss").format(date));
                date = new Date(System.currentTimeMillis());    // 更新时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
线程暂停
yield()
	礼让线程，让当前正在执行的线程暂停，但不阻塞
	将线程从运行状态转为就绪状态
	让CPU重新调度，礼让不一定成功

public class Demo03_ThreadYield {
    public static void main(String[] args) {
        TestYield test01=new TestYield();
        new Thread(test01,"a").start();
        new Thread(test01,"b").start();
    }
}

class TestYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" is run");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+" is yield");
    }
}

礼让不成功：

礼让成功：

线程强制执行
join()
	join方法合并线程，等此线程执行完成后，在执行其他线程，其他线程阻塞
	（------------插队---------------）

public class Demo04_ThreadJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("大佬来了哟！！！");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Demo04_ThreadJoin demo=new Demo04_ThreadJoin();
        Thread thread = new Thread(demo);
        thread.start();;

        for (int i = 0; i < 50; i++) {
            if (i == 20){
                thread.join();
            }
            System.out.println(i);
        }
    }
}
观察线程状态
public class Demo05_ThreadState {

    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("结束");
        });

        // 启动前：     NEW
        Thread.State state = thread.getState();
        System.out.println(state);

        // 启动后：     RUNNABLE
        thread.start();
        state = thread.getState();
        System.out.println(state);

        // 线程不终止就一直执行
        while (state != Thread.State.TERMINATED){
            Thread.sleep(1000);         // 每隔1秒刷新一下状态
            state = thread.getState();      // 更新线程状态
            System.out.println(state);
        }
    }

}
线程优先级
java中有一个线程调度器来监控程序中启动都进入就绪状态的所有线程，
线程调度器按优先级决定应该调度那个线程来执行。

优先级只是意味着调度的概率低，并不是优先级低的就不会被调用了（看CPU调度）

优先级的设定在  start()  方法前

线程优先级，用数字表示，范围：1~10
	Thread.MIN_PRIOPITY = 1
	Thread.NORM_PRIORITY = 5 
	Thread.MAX_PRIORITY = 10

public class Demo06{
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + "---->" + Thread.currentThread().getPriority());

        Test06 test06 = new Test06();
        Thread t1 = new Thread(test06);
        Thread t2 = new Thread(test06);
        Thread t3 = new Thread(test06);
        Thread t4 = new Thread(test06);
        Thread t5= new Thread(test06);

        //  默认为5
        t1.start();

        //
        t2.setPriority(1);
        t2.start();

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

        //  设置最大，，Thread.MAX_PRIORITY
        t4.setPriority(Thread.MAX_PRIORITY);
        t4.start();

        //
        t5.setPriority(8);
        t5.start();

    }
}

class Test06 implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "---->" + Thread.currentThread().getPriority());
    }
}
守护线程
daemon	守护线程

线程分为，，用户线程（eq：main（）），，守护线程（eq：gc()）

虚拟机必须确保用户线程执行完毕，，虚拟机不用等待守护线程执行完成

public class Demo07 {
    public static void main(String[] args) {
        God god = new God();
        People people = new People();

        Thread thread = new Thread(god);
        // 默认为false，，即用户线程，，普通的线程都是用户线程
        thread.setDaemon(true);
        thread.start();

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


// 充当守护线程       虚拟机不用等待守护线程执行完成
class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("上帝一直保护着你");
        }
    }
}

// 充当用户线程       虚拟机必须确保用户线程执行完毕
class People implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 36000; i++) {
            System.out.println("已出生"+i+"天");
        }

        System.out.println("you over！！！");
    }
}
白光一
关注
专栏目录
JavaSE---日志
白豆五的博客
09-05 415
JavaSE-日志
JavaSE-多线程（4）- CAS
sql2008help的博客
11-13 723
JavaSE-多线程（4）- CAS CAS （CompareAndSwap）举例 例1：在此例中，有 THREAD_COUNT （20）个数量的线程调用 AtomicTest 对象m方法，对属性count进行自增操作，最后在主线程打印count的最终结果为20，由于存在多线程多并发访问count，所以在自增操作前使用synchronized关键字对AtomicTest对象进行了锁定。 package com.hs.example.base.multithread.day01; public class
JavaSE-多线程（11）- LockSupport
sql2008help的博客
11-21 529
JavaSE-多线程（11）- LockSupport 使用LockSupport 类可使线程暂停，请看下例： 例1 线程 t1 执行 LockSupportTest 类run方法，在run方法中，每隔1秒输出一次 i 的值，一共输出10次，在i等于5时暂停线程，主线程睡眠8秒后，调用 activate 方法（实际调用 LockSupportTest 对象即锁的notify方法），t1线程继续执行 package com.hs.example.base.multithread.day01; public
JavaSE-多线程（9）- Semaphore
sql2008help的博客
11-20 485
JavaSE-多线程（9）- Semaphore 解释semaphore前先看下以下例子： 例1 有10个线程同时执行SemaphoreTest任务，从执行结果可以看出，10个线程是同时执行的，等待一段时间后结束。 package com.hs.example.base.multithread.day01; public class SemaphoreTest implements Runnable { @Override public void run() { try
JavaSE-多线程基础-基于多线程的计时器应用
wexin_mylove的博客
03-28 1883
JavaSE的多线程的创建以及对于多线程安全的保护，多线程通信以及对于多线程的应用
JavaSE-进阶-学习笔记-JUC
qq_52668773的博客
04-03 2103
​ 管程 (英语：Monitors，也称为监视器) 是一种程序结构，结构内的多个子程序（对象或模块）形成的多个工作线程互斥访问共享资源。​ 这些共享资源一般是硬件设备或一群变量。对共享变量能够进行的所有操作集中在一个模块中。（把信号量及其操作原语“封装”在一个对象内部）管程实现了在一个时间点，最多只有一个线程在执行管程的某个子程序。管程提供了一种机制，管程可以看做一个软件模块，它是将共享的变量和对于这些共享变量的操作封装起来，形成一个具有一定接口的功能模块，进程可以调用管程来实现进程级别的并发控制。
JavaSE--线程1
ggyggy10的博客
12-08 6262
JavaSE--线程一、线程的概念二、使用步骤1.引入库2.读入数据总结新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习
javaSE--多线程2
ggyggy10的博客
12-09 5867
文章目录一、线程的上下文切换1.线程切换存在的问题二、线程安全(同步)问题三、解决线程安全问题--上锁上锁的方法：1.同步方法2.同步代码块3.同步锁synchronize的基本原理锁对象乐观锁和悲观锁乐观锁总结 一、线程的上下文切换 一个CPU内核中同一时间只能运行一个线程或者一行指令，切换到另一个线程的过程称为线程的上下文切换 1.线程切换存在的问题 1.线程切换的时候如何找到上次执行的地方？ 每个线程中都有各自的程序计数器，用于记录上次执行的行数 线程在上下切换时会消耗时间，性能会降低 二、线
JavaSE-多线程(实现线程安全的三种方式)
weixin_43958460的博客
09-09 753
多线程的线程安全问题 案例：如何使用多线程实现卖票问题？ 给出100张票，让3个线程一起买票，且保证票的唯一性和合法性 实现方式一：使用同步代码块 public class RunnableImpl implements Runnable{ //定义一个多个线程共享的票源 private int ticket = 100; //创建一个锁对象 Object ob...
面试-Java一些常见面试题+题解之JavaSE-JavaSE.zip
03-03
- **线程的创建方式**：实现Runnable接口和继承Thread类。 - **线程同步**：synchronized关键字、wait/notify机制、Lock接口。 - **线程池**：ExecutorService、ThreadPoolExecutor的使用与配置。 以上仅是...
javase-思维导图.zip
08-04
Java提供了Thread类和Runnable接口来创建和管理线程，同时还有synchronized关键字、wait()、notify()等同步机制，以及并发工具类如Semaphore、CyclicBarrier等，用于在多线程环境下保证数据的一致性。 最后，Java ...
java8源码-JavaSE-Code:JavaSE的代码练习与学习笔记总结
06-04
interrupted是Thread类的静态方法,里面调用了isTnterrupted方法[currentThread().isInterrupted()],测试当前线程是否已经中断,线程的中断状态由该方法清除 isInterrupted是Thread类的实例方法,不清除中断标志 yield...
面试题总结---javaSE--适用于初学者
07-15
本文将深入解析“面试题总结---javaSE--适用于初学者”这一主题，旨在为初学者提供宝贵的复习资料。 1. **Java基础** - **数据类型**：Java分为基本数据类型（如int、char、boolean等）和引用数据类型（类、接口、...
工厂模式的介绍及实现
最新发布
户伟伟的博客
09-25 69
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Java Stream流编程入门
2301_77207909的博客
09-21 464
Java StreamAPI的使用与常用方法
智能BI平台项目
2302_79400545的博客
09-22 200
BI商业智能：数据可视化、报表可视化系统。
JDK17新增语法特性
2201_76124988的博客
09-20 807
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 585
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
JavaSE中的Thread类详解：启动、命名与优先级设置
"这篇文档主要介绍了Java SE中的Thread类及其常用方法，同时也简述了Java语言的历史、特性以及Java程序的两种主要类型：Applet和Application。Java的平台无关性是其重要特性之一，得益于Java虚拟机（JVM）的支持，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值