【Java学习笔记】线程、同步

最新推荐文章于 2021-11-13 11:19:19 发布
最新推荐文章于 2021-11-13 11:19:19 发布
阅读量159 收藏
点赞数
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lameraaa/article/details/100169857
版权

线程、同步

文章目录

主要内容

  1. 线程
  2. 同步
  3. 线程状态

第一章 线程

1.1 多线程原理

01 多线程随机打印结果
在这里插入图片描述
02 多线程内存图解
在这里插入图片描述

1.2 Thread类

获取线程的名称:

  • 1、使用Thread类中的方法getName()：
    String getName() 返回该线程的名称。
  • 2、可以先获取到当前正在执行的线程,使用线程中的方法getName()获取线程的名称：
    static Thread currentThread() 返回对当前正在执行的线程对象的引用。

例子：

// 定义一个Thread类的子类
public class  MyThread extends Thread{
    //重写Thread类中的run方法,设置线程任务
    @Override
    public void run() {
        //获取线程名称 使用Thread类中的方法getName()
        //String name = getName();
        //System.out.println(name);

		//获取线程名称 使用static Thread currentThread() 的方法getName()
        //Thread t = Thread.currentThread();
        //System.out.println(t);//Thread[Thread-0,5,main]
        //String name = t.getName();
        //System.out.println(name);

        //链式编程
        System.out.println(Thread.currentThread().getName());
    }
}

测试类：

public static void main(String[] args) {
        //创建Thread类的子类对象
        MyThread mt = new MyThread();
        //调用start方法,开启新线程,执行run方法
        mt.start();    // Thread-0

        new MyThread().start();    // Thread-1
        new MyThread().start();    // Thread-2

        //链式编程
        System.out.println(Thread.currentThread().getName());     // main
    }

设置线程的名称:(了解)

  • 1、使用Thread类中的方法setName(名字)
    void setName(String name) 改变线程名称，使之与参数 name 相同。
  • 2、创建一个带参数的构造方法,参数传递线程的名称;调用父类的带参构造方法,把线程名称传递给父类,让父类(Thread)给子线程起一个名字
    Thread(String name) 分配新的 Thread 对象。

例如：

public class MyThread extends Thread{

    public MyThread(){}

    public MyThread(String name){
        super(name);//把线程名称传递给父类,让父类(Thread)给子线程起一个名字
    }

    @Override
    public void run() {
        //获取线程的名称
        System.out.println(Thread.currentThread().getName());
    }
}

测试类

public static void main(String[] args) {
        //开启多线程
        MyThread mt = new MyThread();   
        mt.setName("小强");   // 第一种方式
        mt.start();

        //开启多线程
        new MyThread("旺财").start();     // 第二种方式（带参的构造方法）
    }

sleep

  • public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
    毫秒数结束之后,线程继续执行
    注：1(s) = 1000(ms)
public static void main(String[] args) {
        //模拟秒表
        for (int i = 1; i <=60 ; i++) {
            System.out.println(i);

            //使用Thread类的sleep方法让程序睡眠1秒钟
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

1.3 创建线程方式二

创建多线程程序的第二种方式：实现Runnable接口(推荐使用)

  • java.lang.Runnable
    Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。
  • java.lang.Thread类的构造方法
    Thread(Runnable target) 分配新的 Thread 对象。
    Thread(Runnable target, String name) 分配新的 Thread 对象。

实现步骤:

  1. 创建一个Runnable接口的实现类
  2. 在实现类中重写Runnable接口的run方法,设置线程任务
  3. 创建一个Runnable接口的实现类对象
  4. 创建Thread类对象,构造方法中传递Runnable接口的实现类对象
  5. 调用Thread类中的start方法,开启新的线程执行run方法
//1.创建一个Runnable接口的实现类
public class RunnableImpl implements Runnable{
    //2.在实现类中重写Runnable接口的run方法,设置线程任务
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

测试类

 public static void main(String[] args) {
        //3.创建一个Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象
        //Thread t = new Thread(run);//打印线程名称
        Thread t = new Thread(new RunnableImpl2());//打印HelloWorld
        //5.调用Thread类中的start方法,开启新的线程执行run方法
        t.start();

        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }

实现Runnable接口创建多线程程序的好处:

  • 避免了单继承的局限性
    一个类只能继承一个类(一个人只能有一个亲爹),类继承了Thread类就不能继承其他的类
    但，实现了Runnable接口,还可以继承其他的类,实现其他的接口

  • 增强了程序的扩展性,降低了程序的耦合性(解耦)
    实现Runnable接口的方式,把设置线程任务和开启新线程进行了分离(解耦)
    实现类中,重写了run方法:用来设置线程任务
    创建Thread类对象,调用start方法:用来开启新线程

1.4 匿名内部类方式实现线程的创建

匿名内部类方式实现线程的创建
匿名: 没有名字
内部类: 写在其他类内部的类
匿名内部类作用: 简化代码

  • 把子类继承父类,重写父类的方法,创建子类对象合一步完成
  • 把实现类实现类接口,重写接口中的方法,创建实现类对象合成一步完成

匿名内部类的最终产物: 子类/实现类对象,而这个类没有名字

格式:
    new 父类/接口(){
        重复父类/接口中的方法
    };

例子：

 public static void main(String[] args) {
        //线程的父类是Thread
        // new MyThread().start();
        new Thread(){
            //重写run方法,设置线程任务
            @Override
            public void run() {
                for (int i = 0; i <20 ; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"黑马");
                }
            }
        }.start();

        //线程的接口Runnable
        //Runnable r = new RunnableImpl();//多态
        Runnable r = new Runnable(){
            //重写run方法,设置线程任务
            @Override
            public void run() {
                for (int i = 0; i <20 ; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"程序员");
                }
            }
        };
        new Thread(r).start();

        //简化接口的方式
        new Thread(new Runnable(){
            //重写run方法,设置线程任务
            @Override
            public void run() {
                for (int i = 0; i <20 ; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"传智播客");
                }
            }
        }).start();
    }

第二章 线程安全

2.1 线程安全

线程安全问题描述
在这里插入图片描述

实现卖票程序

/*
    实现卖票案例
 */
public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private  int ticket = 100;

    //设置线程任务:卖票
    @Override
    public void run() {
        //使用死循环,让卖票操作重复执行
        while(true){
            //先判断票是否存在
            if(ticket>0){
                //提高安全问题出现的概率,让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                //票存在,卖票 ticket--
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
        }
    }
}

测试类

/*
    模拟卖票案例
    创建3个线程,同时开启,对共享的票进行出售
 */
public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
        //创建Thread类对象,构造方法中传递Runnable接口的实现类对象
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        //调用start方法开启多线程
        t0.start();
        t1.start();
        t2.start();
    }
}

线程安全问题产生的原理
在这里插入图片描述

2.2 线程同步

卖票案例出现了线程安全问题
卖出了不存在的票（0，-1）和重复的票

要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制 (synchronized) 来解决。

那么怎么去使用呢？有三种方式完成同步操作：
    1. 同步代码块。 2. 同步方法。 3. 锁机制。]]

2.3 解决线程安全问题的一种方案: 使用同步代码块

同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
格式:

synchronized(锁对象){
       可能会出现线程安全问题的代码(访问了共享数据的代码)
    }

注意:

  1. 通过代码块中的锁对象,可以使用任意的对象
  2. 但是必须保证多个线程使用的锁对象是同一个
  3. 锁对象作用:
    把同步代码块锁住,只让一个线程在同步代码块中执行
public class    RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private  int ticket = 100;

    //创建一个锁对象
    Object obj = new Object();

    //设置线程任务:卖票
    @Override
    public void run() {
        //使用死循环,让卖票操作重复执行
        while(true){
           //同步代码块
            synchronized (obj){
                //先判断票是否存在
                if(ticket>0){
                    //提高安全问题出现的概率,让程序睡眠
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    //票存在,卖票 ticket--
                    System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                    ticket--;
                }
            }
        }
    }
}

2.4 解决线程安全问题的二种方案:使用同步方法

同步方法: 使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。

格式:

    修饰符 synchronized 返回值类型 方法名(参数列表){
       		可能会出现线程安全问题的代码(访问了共享数据的代码)
    }

使用步骤:

  1. .把访问了共享数据的代码抽取出来,放到一个方法中
  2. 在方法上添加synchronized修饰符

例如：

public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private static int ticket = 100;


    //设置线程任务:卖票
    @Override
    public void run() {
        System.out.println("this:"+this);//this:com.itheima.demo08.Synchronized.RunnableImpl@58ceff1
        //使用死循环,让卖票操作重复执行
        while(true){
            payTicketStatic();
        }
    }

    /*
        静态的同步方法
        锁对象是谁?
        不能是this
        this是创建对象之后产生的,静态方法优先于对象
        静态方法的锁对象是本类的class属性-->class文件对象(反射)
     */
    public static /*synchronized*/ void payTicketStatic(){
        synchronized (RunnableImpl.class){
            //先判断票是否存在
            if(ticket>0){
                //提高安全问题出现的概率,让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                //票存在,卖票 ticket--
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
        }

    }

    /*
        定义一个同步方法
        同步方法也会把方法内部的代码锁住
        只让一个线程执行
        同步方法的锁对象是谁?
        就是实现类对象 new RunnableImpl()
        也是就是this
     */
    public /*synchronized*/ void payTicket(){
        synchronized (this){
            //先判断票是否存在
            if(ticket>0){
                //提高安全问题出现的概率,让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                //票存在,卖票 ticket--
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }
        }

    }
}

2.5 解决线程安全问题的三种方案:使用Lock锁

java.util.concurrent.locks.Lock接口
Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。
Lock接口中的方法:

  1. void lock() 获取锁。
  2. void unlock() 释放锁。

java.util.concurrent.locks.ReentrantLock implements Lock接口

使用步骤:

  1. 在成员位置创建一个ReentrantLock对象
  2. 在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
  3. 在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁

例如：

public class RunnableImpl implements Runnable{
    //定义一个多个线程共享的票源
    private  int ticket = 100;

    //1.在成员位置创建一个ReentrantLock对象
    Lock l = new ReentrantLock();

    //设置线程任务:卖票
    @Override
    public void run() {
        //使用死循环,让卖票操作重复执行
        while(true){
           //2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
           l.lock();

            //先判断票是否存在
            if(ticket>0){
                //提高安全问题出现的概率,让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                //票存在,卖票 ticket--
                System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                ticket--;
            }

            //3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁
            l.unlock();
        }
    }
}

使用finally改良

//设置线程任务:卖票
    @Override
    public void run() {
        //使用死循环,让卖票操作重复执行
        while(true){
            //2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
            l.lock();

            //先判断票是否存在
            if(ticket>0){
                //提高安全问题出现的概率,让程序睡眠
                try {
                    Thread.sleep(10);
                    //票存在,卖票 ticket--
                    System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
                    ticket--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    //3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁
                    l.unlock();//无论程序是否异常,都会把锁释放
                }
            }
        }
    }

第三章 线程状态

3.1 线程状态描述、

线程状态图：（6种状态）
在这里插入图片描述

3.2 等待唤醒在这里插入图片描述

等待唤醒案例分析：
在这里插入图片描述
等待唤醒案例:线程之间的通信

  • 创建一个顾客线程(消费者):告知老板要的包子的种类和数量,调用wait方法,放弃cpu的执行,进入到WAITING状态(无限等待)
  • 创建一个老板线程(生产者):花了5秒做包子,做好包子之后,调用notify方法,唤醒顾客吃包子

注意:

  • 顾客和老板线程必须使用同步代码块包裹起来,保证等待和唤醒只能有一个在执行
  • 同步使用的锁对象必须保证唯一
  • 只有锁对象才能调用wait和notify方法

Obejct类中的方法

  • void wait() 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。
  • void notify()
    唤醒在此对象监视器上等待的单个线程。
    会继续执行wait方法之后的代码
public class Demo01WaitAndNotify {
    public static void main(String[] args) {
        //创建锁对象,保证唯一
        Object obj = new Object();
        // 创建一个顾客线程(消费者)
        new Thread(){
            @Override
            public void run() {
               //一直等着买包子
               while(true){
                   //保证等待和唤醒的线程只能有一个执行,需要使用同步技术
                   synchronized (obj){
                       System.out.println("告知老板要的包子的种类和数量");
                       //调用wait方法,放弃cpu的执行,进入到WAITING状态(无限等待)
                       try {
                           obj.wait();
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                       //唤醒之后执行的代码
                       System.out.println("包子已经做好了,开吃!");
                       System.out.println("---------------------------------------");
                   }
               }
            }
        }.start();

        //创建一个老板线程(生产者)
        new Thread(){
            @Override
            public void run() {
                //一直做包子
                while (true){
                    //花了5秒做包子
                    try {
                        Thread.sleep(5000);//花5秒钟做包子
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    //保证等待和唤醒的线程只能有一个执行,需要使用同步技术
                    synchronized (obj){
                        System.out.println("老板5秒钟之后做好包子,告知顾客,可以吃包子了");
                        //做好包子之后,调用notify方法,唤醒顾客吃包子
                        obj.notify();
                    }
                }
            }
        }.start();
    }
}

3.3 计时等待

进入到TimeWaiting(计时等待)有两种方式

  • 使用sleep(long m)方法，在毫秒值结束之后,线程睡醒进入到Runnable/Blocked状态
  • 使用wait(long m)方法，wait方法如果在毫秒值结束之后,还没有被notify唤醒,就会自动醒来,线程睡醒进入到Runnable/Blocked状态

唤醒的方法:

  • void notify() 唤醒在此对象监视器上等待的单个线程。
  • void notifyAll() 唤醒在此对象监视器上等待的所有线程。
public class Demo02WaitAndNotify {
    public static void main(String[] args) {
        //创建锁对象,保证唯一
        Object obj = new Object();
        // 创建一个顾客线程(消费者)
        new Thread(){
            @Override
            public void run() {
                //一直等着买包子
                while(true){
                    //保证等待和唤醒的线程只能有一个执行,需要使用同步技术
                    synchronized (obj){
                        System.out.println("顾客1告知老板要的包子的种类和数量");
                        //调用wait方法,放弃cpu的执行,进入到WAITING状态(无限等待)
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的代码
                        System.out.println("包子已经做好了,顾客1开吃!");
                        System.out.println("---------------------------------------");
                    }
                }
            }
        }.start();

        // 创建一个顾客线程(消费者)
        new Thread(){
            @Override
            public void run() {
                //一直等着买包子
                while(true){
                    //保证等待和唤醒的线程只能有一个执行,需要使用同步技术
                    synchronized (obj){
                        System.out.println("顾客2告知老板要的包子的种类和数量");
                        //调用wait方法,放弃cpu的执行,进入到WAITING状态(无限等待)
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的代码
                        System.out.println("包子已经做好了,顾客2开吃!");
                        System.out.println("---------------------------------------");
                    }
                }
            }
        }.start();

        //创建一个老板线程(生产者)
        new Thread(){
            @Override
            public void run() {
                //一直做包子
                while (true){
                    //花了5秒做包子
                    try {
                        Thread.sleep(5000);//花5秒钟做包子
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    //保证等待和唤醒的线程只能有一个执行,需要使用同步技术
                    synchronized (obj){
                        System.out.println("老板5秒钟之后做好包子,告知顾客,可以吃包子了");
                        //做好包子之后,调用notify方法,唤醒顾客吃包子
                        //obj.notify();//如果有多个等待线程,随机唤醒一个
                        obj.notifyAll();//唤醒所有等待的线程
                    }
                }
            }
        }.start();
    }
}
Nine_xu
关注
专栏目录
处理多线程的第三种方式:匿名内部类
dkbfhbh的博客
08-08 293
匿名内部类使用较少
匿名内部类和多线程
qq_41280118的博客
08-24 593
匿名内部类和多线程 1. 匿名内部类 1.1 接口 interface A { 成员变量 缺省属性 public static final 定义时必须初始化 成员方法 缺省属性 public abstract 该方法没有方法体 默认方法 default修饰，当前方法可以拥有方法体 JDK 1.8 新特征 } 一个类遵从接口 class TypeA implements A { 要求实现接口中所有缺省属性为pubilc abstract成员方法 } 当前类创建对象之后，我们就可以调用当前TypeA
Thread + 匿名内部类
a8153285的博客
09-10 751
package chapter01; public class MyThread01 extends Thread{ @Override public void run() { //让当前线程执行的代码编写在run方法中 for(int i=0; i<=100; i++) { System.out.println("发微信" + i); } } }...
使用匿名内部类对象来实现线程的创建和启动
qq_43555873的博客
11-13 106
代码如下： new Thread("新的线程！"){ @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println(getName()+"：正在执行！"+i); } } }.start(); new Thread(new Runnable(){ @Override publi...
匿名内部类实现多线程
全栈世界
06-16 926
匿名内部实现多线程 JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。 package com.zyw.perform.test; import com.zyw.perform.PerformApplication; import org.springframework.boot.SpringApplication; /
Java中线程同步和线程协作学习笔记
05-27
在Java编程中，线程同步和线程协作是多线程编程的重要概念，确保了在并发环境下程序的正确性和数据的一致性。线程同步的主要目标是解决线程安全问题，即在多线程访问共享资源时避免数据的混乱，保证程序的可再现性。...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
java学习笔记markdown
03-12
【Java学习笔记Markdown版】是针对Java初学者和进阶者的一份详尽教程，以Markdown格式编写，便于阅读和整理。Markdown是一种轻量级的标记语言，它允许用户使用易读易写的纯文本格式编写文档，然后转换成结构化的HTML...
java struts2学习笔记之线程安全
09-02
因此，Action是线程安全的，开发者在编写Action时不需要特别关注线程同步问题，可以更专注于业务逻辑。 然而，尽管Action本身是线程安全的，但Action中的依赖（如服务层对象、DAO对象等）可能不是。如果这些依赖在...
多线程-狂神说Java学习笔记
最新发布
07-19
本学习笔记将深入探讨Java多线程的相关知识，包括其原理、实现方式、同步机制以及常见问题。 ### 一、多线程的基本概念 多线程是指在一个程序中存在两个或更多的执行线程，这些线程共享同一内存空间，但各自拥有...
匿名内部类方式实现线程的创建
xxxjackboy的博客
11-13 225
匿名内部类方式实现线程的创建 匿名：没有名字 内部类：写在其他类内部的类 匿名内部类作用：简化代码 把子类继承父类，重写父类的方法，创建子类对象合成一步完成 把实现类接口，重写接口中的方法，创建实现类对象合成一步完成 匿名内部类的最终产物：子类/实现类对象，这个类没有名字 格式： new 父类/接口（）｛ 重复父类/接口中的方法 ｝； public class demo01InnerClassThread { public static void main(String[] args) { //线程
Thread 匿名内部类
Ssssongsmith 天璇星
12-18 285
匿名内部类创建线程
蓝墨の学习笔记
04-20 168
package chapter1; public class Demo2 { public static void main(String[] args) { // Runnable runnable = new Runnable() { // @Override // public void run() { // ...
Thread类实现接口方式和匿名内部类方式
阅后即焚
09-25 2928
Thread类 构造方法： public Thread():分配一个新的线程对象。 public Thread(String name):分配一个指定名字的新的线程对象。 public Thread(Runnable target):分配一个带有指定目标新的线程对象。 public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字...
匿名内部类开启线程
qq_40707269的博客
08-11 401
import java.util.Scanner; /*匿名内部类创建多线程 1.匿名，顾名思义，没有名字，用于简化代码 把子类继承父类，重写父类方法，创建子类对象合成一步完成 把实现类接口，重写接口中方法，创建实现类对象合成一步完成 2.内部类，写在其他类内部 最终产物，创建子类/实现类对象 方法； new 父类/接口（）{ 重写方法 } */ public class Queue { public static void main(String[]..
Java中线程的匿名内部类使用
hekaikai666的博客
04-20 2139
    对于线程匿名内部类的使用在于开发中小微型程序非常广泛，特别是在多层处理方面，使用匿名内部类非常方便。    匿名类最大的特点就是匿名了。。（感觉是废话）既然是匿名类，所以你无法在别的地方使用这个类（实例化，调用它的静态方法之类的）    特点的话，除了只能使用一次，其实还有其他用处（在看spring-boot源码时发现的）    当你想使用一个类的protected 方法时，但是又不和这个...
java thread 匿名_Java 匿名内部类
weixin_34856444的博客
02-19 1535
语法匿名内部类适合那种只需要使用一次的类。创建匿名类的同时会立即创建一个该类的实例，这个类不能重复使用。new interface|superClass(){//匿名内部类}可见，匿名类必须继承一个父类或一个接口，且最多一个。还要注意，匿名内部类不能定义静态初始化代码块，不能在匿名类里面定义接口，不能在匿名类中定义构造函数。匿名类就是一个继承的子类，也可以多重匿名(多重子类)。常用匿名类写法注意辨...
匿名内部类方式实现线程创建的三种方式
欢迎你的到来，我们一起加油！！！
08-30 850
小demo package demo04; /** * @author wh * @date 2021年08月30日15:57 * 匿名内部类方式实现线程创建的三种方式 */ public class demo02 { public static void main(String[] args) { //第一种 创建Thread线程 new Thread(){ @Override public void ru
Java多线程学习笔记：线程状态与同步机制
`synchronized`关键字是Java中的系统锁，提供了一种线程同步的机制，确保同一时刻只有一个线程可以访问被锁定的代码块或方法。它具有可重入性，即一个线程可以多次进入被其持有的锁所保护的代码块。在异常情况下，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值