Java基础、多线程（Synchronized、volatile、CAS）

最新推荐文章于 2024-07-23 09:54:26 发布

阿兰你在哪

最新推荐文章于 2024-07-23 09:54:26 发布

阅读量180

点赞数 2

分类专栏： java基础

本文链接：https://blog.csdn.net/qq_40945081/article/details/107779295

版权

本文深入探讨Java多线程，详细解析线程同步中的Synchronized关键字，包括锁对象、可重入性、异常处理，以及volatile特性和线程安全性。同时，介绍了CAS无锁优化和单例模式的线程安全实现。

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

多线程

多线程

多线程

1.1 线程的概念启动方式和常用方法

1.1.1 线程的概念

线程：线程是cpu调度的最小单位，线程切换开销小，
进程：进程是资源分配的最小单位，进程切换开销大，一个进程包含很多线程
线程和进程的一样分为五个阶段：创建、就绪、运行、阻塞、终止。

public class T1_WhatIsThread implements Runnable{
   
    @Override
    public void run() {
   
        try {
   
            TimeUnit.MICROSECONDS.sleep(1);
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
        System.out.println("T1");
    }

    public static void main(String[] args) {
   
//        new T1().run();
        new Thread(new T1_WhatIsThread()).start();
        try {
   
            TimeUnit.MICROSECONDS.sleep(1);
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
        System.out.println("main");
    }
}

1.1.2 启动线程的方式

继承Thread
实现Runnable
通过线程池来启动
lambda表达式

public class T2_HowToCreatThread {
   
    //使用到了静态内部类，什么时候使用静态内部类呢？静态内部类有什么特点？
    /**
     * 当需要把一个类隐藏在另外一个类的内部并且不需要使用外部类的引用的时候就可以使用静态内部类
     * 静态内部类的特点：
     * 1.与常规内部类不同，静态内部类可以有静态域和方法
     * 2.声明在接口中的内部类默认修饰是public static
     */
    static class MyThread extends Thread{
   
        @Override
        public void run(){
   
            System.out.println("Hello myThread!");
        }
    }

    static class MyRun implements Runnable{
   

        @Override
        public void run() {
   
            System.out.println("Hello Run!");
        }
    }

    public static void main(String[] args) {
   
        new MyThread().start();//继承Thread类，重写其中的Run方法
        new Thread(new MyRun()).start();//实现Runnable接口实现Run方法
        new Thread(new Runnable() {
   //lambda表达式实现run方法，Runnable是一个函数式接口
            @Override
            public void run() {
   
                System.out.println("lambda表达式");
            }
        }).start();
        System.out.println("main");
    }
}

1.1.3 线程的常用方法

yield 让出时间片
sleep 线程休眠固定时长
join 一个线程等待另外一个线程结束之后执行
getState 获取线程状态，不同操作系统线程状态个数不一致

public class T3_Sleep_yield_join {
   
    public static void main(String[] args) {
   
//        testSleep();//sleep TimeWaiting状态，等待时间结束之后线程重新进入就绪状态
//        testYield();//调用Yield的线程会让出时间片，重新进入就绪状态，可能下一次调用的还是让出时间片的线程
        testJoin();//在某个线程内调用 x.join()，当前调用线程就要等待x线程执行结束之后继续执行
    }
    static void testSleep(){
   
        new Thread(()->{
   
            for (int i=0;i<100;i++){
   
                try {
   
                    Thread.sleep(500);
                    System.out.println("500ms输出一次，输出："+i);
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
        }).start();
    }
    static void testYield(){
   
        new Thread(()->{
   
            for (int i=0;i<10;i++){
   
                System.out.println("输出之后让出时间片，输出"+i);
                Thread.yield();
            }
        }).start();
        new Thread(()->{
   
            for (int i=0;i<10;i++){
   
                System.out.println("线程二输出，输出"+i);
                if (i==5){
   
                    Thread.yield();
                }
            }
        }).start();
    }
    static void testJoin(){
   
        Thread t1 = new Thread(() -> {
   
            for (int i = 0; i < 10; i++) {
   
                System.out.println("t2输出到5之后，要等待我执行结束，输出" + i);
            }
        });
        Thread t2 = new Thread(() -> {
   
            for (int i = 0; i < 10; i++) {
   
                System.out.println("我是t2，输出" + i)