Java 多线程（小结）

最新推荐文章于 2024-07-21 22:27:18 发布
最新推荐文章于 2024-07-21 22:27:18 发布
阅读量136 收藏
点赞数
分类专栏： Java基础 多线程 文章标签： 多线程 java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LK_Lawliet/article/details/108089459
版权

多线程

1、线程与进程

进程

  • 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

线程

  • 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行。一个进程最少 有一个线程

进程和线程的关系：

（1）一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。

（2）资源分配给进程，同一进程的所有线程共享该进程的所有资源。

（3）线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。

（4）处理机分给线程，即真正在处理机上运行的是线程。

（5）线程是指进程内的一个执行单元，也是进程内的可调度实体。

进程与线程的区别：

（1）调度：进程是系统进行资源分配和调度的基本单位，线程是进程中CPU分配和调度的基本单位。

（2）并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可以并发执行。

（3）拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源。

2、线程调度

分时调度

  • 所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度 （Java）

  • 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)。

CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核来说，某个时刻， 只能执行一个线程，而CPU在多个线程之间的切换速度相对我们的感觉要快，看上去就像在同一时刻运行。其实，多线程程序并不能提高程序的运行速度，但能让CPU的使用率更高。

3、同步与异步

同步

  • 所有的操作都做完，才返回给用户结果。（排队执行 , 效率低但是安全）

异步

  • 不用等所有操作都做完，就响应用户请求。（同时执行 , 效率高但是数据不安全）

同步：你用热水壶烧一壶水，你要一直等着，直到水烧开，你再往杯子里倒。

异步：你用热水壶烧一壶水，这段时间里，你不需要等着，你可以去做其他事情，等水烧好，你再去往杯子倒。

4、并发与并行

并发：指两个或多个事件在同一个时间段内发生。

并行：指两个或多个事件在同一时间点发生（同时发生）。

通过一张图来更好的理解一下两者的区别：

并发与并行

5、多线程创建的方式

（1）继承Thread类

public static void main(String[] args) {
	MyThread m = new MyThread();
    m.start();
    for (int i = 0; i < 10; i++) {
    	System.out.println("主线程" + i);
    }
}

public class MyThread extends Thread{
    // 重写run()方法
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {java
            System.out.println("子线程" + i);
        }
    }
}

在这里插入图片描述

（2）实现Runnable接口

public static void main(String[] args) {
    // 1、创建一个任务对象
    MyRunnable r = new MyRunnable();
    // 2、创建一个线程，并为其分配一个任务
    Thread t = new Thread(r);
    // 3、执行这个线程
    t.start();
    for (int i = 0; i < 10; i++) {
        System.out.println("主线程" + i);
    }
}

public class MyRunnable implements Runnable{
    // 重写run()方法
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程" + i);
        }
    }
}

（3）实现Callable接口

// 1.编写类实现Callable接口 , 实现call方法
	class XXX implements Callable<T> {
		@Override
		public <T> call() throws Exception {
			return T;
		}
	}
// 2.创建FutureTask对象 , 并传入第一步编写的Callable类对象
	FutureTask<Integer> future = new FutureTask<>(callable);
// 3.通过Thread,启动线程
	new Thread(future).start();

（4）通过线程池创建

实现Runnable与继承Thread相比有如下优势

  • 通过创建任务给线程分配的方式来实现的多线程。更适合多个线程同时执行相同任务的情况。
  • 可以避免单继承所带来的局限性。
  • 任务与线程本身是分离的，提高了程序的健壮性。
  • 线程池技术，接受Runnable类型的任务，不接收Thread 类型的线程。

Runnable和Callable的区别

  • Callable（重写）的方法是call()，Runnable（重写）的方法是run()。
  • Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
  • Call方法可以抛出异常，run方法不可以。
  • 运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。

6、获取和设置线程名称

public static void main(String[] args) {
    // currentThread()返回对当前正在执行的线程对象的引用
    System.out.println(Thread.currentThread().getName());
    // 方式一(默认)
    new Thread(new MyRunnable()).start();
    // 方式二
    new Thread(new MyRunnable(),"子线程1").start();
    // 方式三
    Thread t = new Thread(new MyRunnable());
    t.setName("子线程2");
    t.start();
}

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

7、线程中断

/**
 * 想要在main线程执行完就结束，无论子线程是否执行完毕
 */
public static void main(String[] args) throws InterruptedException {
    Thread t = new Thread(new MyRunnable());
    t.setName("子线程");
    t.start();
    for (int i = 0; i < 5; i++) {
        System.out.println(Thread.currentThread().getName() + ":" + i);
        Thread.sleep(1000);
    }
    // 方法：给子线程t添加中断标记，子线程在特殊操作时会检查标记，发现中断标记后会抛出异常，进入try-catch{}内
    t.interrupt();
}
static class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                //e.printStackTrace();
                System.out.println("发现中断标记，子线程自杀！");
                // return即表示run()方法结束
                return;
            }
        }
    }
}

8、守护线程

线程：分为用户线程和守护线程

  • 用户线程：当一个进程不包含任何的存活的用户线程时，进程结束。
  • 守护线程：守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡。
Thread t = new Thread();
// 将子线程t设置为守护线程（注意：在start()方法前进行设置）
t.setDaemon(true);
t.start();

9、线程安全（解决方法）

（1）synchronized（隐式锁）

  • ① 同步代码块

/**
 * 多线程存在线程不安全问题
 * （几个线程一块卖票，如不考虑线程安全问题，则会抢着卖票，可能会有负数余票）
 * 解决方案1：同步代码块
 * 格式  synchronized (锁对象){
 *          // 注意必须是同一个锁对象
 *      }
 */
public static void main(String[] args) {
    Runnable r = new MyRunnable();
    new Thread(r).start();
    new Thread(r).start();
}
static class MyRunnable implements Runnable{
    // 票数
    int count = 10;
    // 必须是同一个对象的锁
    Object o = new Object();
    @Override
    public void run() {
        /**
         * 如果在线程run()方法内部创建对象
         * 那么有几个线程就在启动时会创建几个对象
         * 每个线程只看自己的对象的锁（则不需要排队），那么将无法解决线程安全问题
         */
        // Object o = new Object();
        while (true){
            // 加入同步代码块
            synchronized (o){
                if (count > 0){
                    System.out.print(Thread.currentThread().getName() + "正在准备卖票,");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count --;
                    System.out.println("余票:" + count);
                }else {
                    break;
                }
            }
        }
    }
}

  • ② 同步方法

/**
 * 多线程存在线程不安全问题
 * 解决方案2：同步方法
 *      给方法添加synchronized修饰
 */
public static void main(String[] args) {
    Runnable r = new MyRunnable();
    new Thread(r).start();
    new Thread(r).start();
}
static class MyRunnable implements Runnable{
    // 票数
    int count = 10;
    @Override
    public void run() {
        while (true){
            boolean flag = sale();
            if (!flag){
                break;
            }
        }
    }
    // 给方法添加synchronized修饰
    public synchronized boolean sale(){
    /**
     * 锁对象
     *   如果不是static修饰的方法，则锁对象是 this(谁调用方法就是谁)
     *   如果是static修饰的方法，则锁对象是 MyRunnable.class
     */
        if (count > 0){
            System.out.print(Thread.currentThread().getName() + "正在准备卖票,");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            count --;
            System.out.println("出票成功,余票:" + count);
            return true;
        }
        return false;
    }
}

（2）Lock（显式锁）

/**
 * 多线程存在线程不安全问题
 * 解决方案3：显式锁 Lock
 *      Lock 子类 ReentrantLock
 *      自己创建锁，执行方法前加锁，方法执行完毕后释放锁
 */
public static void main(String[] args) {
    Runnable r = new MyRunnable();
    new Thread(r).start();
    new Thread(r).start();
}
static class MyRunnable implements Runnable{
    // 票数
    int count = 10;
    // 显式锁 Lock
    Lock l = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            // 加锁
            l.lock();
            if (count > 0){
                System.out.print(Thread.currentThread().getName() + "正在准备卖票,");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count --;
                System.out.println("出票成功,余票:" + count);
            }else {
                break;
            }
            // 释放锁
            l.unlock();
        }
    }
}

10、公平锁与非公平锁

ReentrantLock实现了Lock接口，ReentrantLock的内部类Sync继承了AQS，分为

  • 公平锁（FairSync）：线程获取锁的顺序和调用lock的顺序一样，FIFO；
  • 非公平锁（NonfairSync）：线程获取锁的顺序和调用lock的顺序无关，全凭运气抢。
/**
 * Java中默认为 非公平锁
 * fair参数为 true，就表示为 公平锁
 */
Lock l = new ReentrantLock(true);

11、生产者与消费者

/**
 * 生产者与消费者（简单案例）
 */
public static void main(String[] args) {
    Food f = new Food();
    new Chef(f).start();
    new Waiter(f).start();
}
// 生产者(线程) — 厨师 ---------------------------------------------------------
static class Chef extends Thread{
    private Food f;
    public Chef(Food f) {
        this.f = f;
    }
    @Override
    public void run() {
        // 生产者生产20份（2种）菜品
        for (int i = 0; i < 20; i++) {
            if (i%2 == 0){
                f.setNameAndTaste("小米粥","咸味");
            }else {
                f.setNameAndTaste("八宝粥","甜味");
            }
        }
    }
}
// 消费者(线程) — 服务员 ---------------------------------------------------------
static class Waiter extends Thread{
    private Food f;
    public Waiter(Food f) {
        this.f = f;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            f.get();
        }
    }
}
// 数据 - 食物 -----------------------------------------------------------------
static class Food{
    private String name;
    private String taste;
    // 添加一个标记，true表示可以生产
    private boolean flag = true;
    public synchronized void setNameAndTaste(String name,String taste){
        // 生产者开始生产
        if (flag){
            this.name = name;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.taste = taste;
            // 生产者生成完毕，改为false，停止生产
            flag = false;
            // 唤醒消费者线程(唤醒在当前this下 等待的所有线程)
            this.notifyAll();
            // 生产者线程进入等待状态
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    // 消费方法
    public synchronized void get(){
        // 消费者开始消费
        if (!flag){
            System.out.println("服务员端走的菜是:" + name + ",味道是:" + taste);
            // 消费者消费完毕，改为true，停止消费
            flag = true;
            // 唤醒生产者线程
            this.notifyAll();
            // 消费者线程进入等待状态
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

12、线程的基本状态

  • 新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread()；

  • 就绪状态（Runnable）：当调用线程对象的start()方法时，线程即进入就绪状态，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；

  • 运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。**注：**就绪状态是进入运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；

  • 阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态。

    • 等待阻塞 – 运行状态中的线程执行wait()方法，使该线程进入到等待阻塞状态；
    • 同步阻塞 – 线程在获取synchronized同步锁失败，它会进入同步阻塞状态；
    • 其他阻塞 – 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。

  • 等待（Waiting）：无限期等待另一个线程执行特定操作的线程处于此状态。

  • 时间等待（Timed_Waiting）：正在等待另一个线程执行指定等待时间的操作的线程处于此状态。

  • 死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

线程同步以及线程调度相关的方法

（1）wait()：使一个线程处于等待（阻塞）状态，并且释放所持有的对象的锁；

（2）sleep()：使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要处理 InterruptedException 异常；

（3）notify()：唤醒一个处于等待状态的线程，并且是由 JVM 确定唤醒哪个线程，而且与优先级无关；

（4）notityAll()：唤醒所有处于等待状态的线程，并且让它们竞争锁，只有获得锁的线程才能进入就绪状态；

sleep() 和 wait() 有什么区别？

两者都可以暂停线程的执行

  • sleep()：是 Thread线程类的静态方法，调用 sleep 后，当前线程会让出cpu的使用权，自己进入休眠状态，但并不会释放锁，在休眠时间结束后，恢复之前的运行状态。（sleep 通常被用于暂停执行）
  • wait() ：是 Object类的方法，调用 wait 后，当前线程会让出cpu的使用权，进入等待阻塞状态，并且释放所持有对象的锁，只有在调用了notify，notifyAll方法后，该线程才会被唤醒，重新去获取对象的锁。（Wait 通常被用于线程间交互/通信）

13、线程池概述

线程池就是提前创建若干个线程，如果有任务需要处理，线程池里的线程就会处理任务，处理完之后线程并不会被销毁，而是等待下一个任务

四种线程池的创建：

（1）newCachedThreadPool 创建一个可缓存线程池

/**
 * 缓存线程池 (长度无限制)
 * 执行流程:
 * 		1. 判断线程池是否存在空闲线程
 * 		2. 存在则使用
 * 		3. 不存在,则创建线程 并放入线程池, 然后使用
 */
ExecutorService service = Executors.newCachedThreadPool();
//向线程池中加入新的任务
service.execute(new Runnable() {
    @Override
    public void run() {
        System.out.println("线程的名称:"+Thread.currentThread().getName());
    }
});

（2）newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数。

/**
 * 定长线程池 (长度是指定的数值)
 * 执行流程:
 * 		1. 判断线程池是否存在空闲线程
 * 		2. 存在则使用
 * 		3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池,然后使用
 * 		4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
 */
ExecutorService service = Executors.newFixedThreadPool(2);
service.execute(new Runnable() {
	@Override
	public void run() {
		System.out.println("线程的名称:"+Thread.currentThread().getName());
	}
});
service.execute(new Runnable() {
	@Override
	public void run() {
		System.out.println("线程的名称:"+Thread.currentThread().getName());
	}
});

（3）newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

/**
 * 周期任务 定长线程池
 * 周期性任务执行时: 定时执行, 当某个时机触发时, 自动执行某任务 
 */
ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
/**
 * 定时执行
 * 		参数1. runnable类型的任务
 * 		参数2. 时长数字
 * 		参数3. 时长数字的单位
 */
service.schedule(new Runnable() {
	@Override
	public void run() {
		System.out.println("俩人相视一笑~ 嘿嘿嘿");
	}
},5,TimeUnit.SECONDS);
/**
 * 周期执行
 * 		参数1. runnable类型的任务
 * 		参数2. 时长数字(延迟执行的时长)
 * 		参数3. 周期时长(每次执行的间隔时间)
 * 		参数4. 时长数字的单位
 */
service.scheduleAtFixedRate(new Runnable() {
	@Override
	public void run() {
		System.out.println("俩人相视一笑~ 嘿嘿嘿");
	}
},5,2,TimeUnit.SECONDS);

（4）newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务。

/**
 * 单线程线程池 (效果与定长线程池 创建时传入 数值1 效果一致)
 */
ExecutorService service = Executors.newSingleThreadExecutor();
service.execute(new Runnable() {
	@Override
	public void run() {
		System.out.println("线程的名称:"+Thread.currentThread().getName());
	}
});

线程池的优点：

（1）重复使用线程池里的线程，减少对象创建销毁的开销。

（2）可有效的控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。

（3）提供定时执行、定期执行、单线程、并发数控制等功能。

14、Lambda 表达式

Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。

Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

使用 Lambda 表达式可以使代码变的更加简洁紧凑。

// 正常格式
public static void main(String[] args) {
    print(new MyMath() {
        @Override
        public int sum(int x,int y) {
            return x+y;
        }
    },100,200);
}
public static void print(MyMath m,int x,int y){
    int num = m.sum(x,y);
    System.out.println(num);
}
static interface MyMath{
    int sum(int x,int y);
}

// Lambda 表达式
public static void main(String[] args) {
    print((int x, int y) -> { return x+y; },100,200);
}
public static void print(MyMath m,int x,int y){
    int num = m.sum(x,y);
    System.out.println(num);
}
static interface MyMath{
    int sum(int x,int y);
}
LK_Lawliet
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于java多线程实验小结_java 多线程 小结
weixin_31201481的博客
02-27 1931
java有点不同，实现多线程有两种方式：继承类Thread， 和 实现接口Runnable。thread类有一个run函数，它是线程的入口，当启动一个新线程是，就从这个函数开始执行；View Codepublic class ThreadTest extendsThread{public voidrun(){for (int i=0;i<5;i++){try{Thread.sleep(10...
Java多线程小结
10-26
Java中多线程的学习的自我小结，有多线程的意思，多线程常见的控制方法等内容
Java 多线程小结
一枝韩独秀的博客
02-26 1168
1 程序、进程、线程的概念 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 进程(process)是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。 如：运行中的QQ，运行中的MP3播放器 程序是静态的，进程是动态的 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。 若...
java 多线程死掉_java多线程小结，及解决应用挂死的问题
weixin_26805451的博客
02-13 860
这两天为了定位JBOSS老是挂死的问题，学习了一下JAVA多线程方面的知识，在此总结一下。此文为转载1、在Java程序中，JVM负责线程的调度。线程调度是指按照特定的机制为多个线程分配CPU的使用权。调度的模式有两种：分时调度和抢占式调度。分时调度是所有线程轮流获得CPU使用权，并平均分配每个线程占用CPU的时间；抢占式调度是根据线程的优先级别来获取CPU的使用权。JVM的线程调度模式采用了抢占...
java多线程小结
虎子专栏
10-23 406
JAVA多线程调试经验小结
qq_21575929的博客
07-22 640
1. 业务场景：按照正常的调试经验点击F5,F6，F8时代码得出的结果与预期不一致，经高手指点，总结一下多线程调用时调试经验。 2. 方法: 正常使用debug模式时，debug视窗会弹出各种线程Dameon之类的提示，重点就在这个视窗 正常多线程提交时大概分两步： 1. 初始化线程池(ThreadPoolExecutor) 2. 提交(submit)给线程池执行call方法 重点就在这个第二步，正常debug到第二部...
java多线程小结，及解决应用挂死的问题
liwenshui322的专栏
08-12 963
原博客地址：http://kyfxbl.iteye.com/blog/1370377 这两天为了定位JBOSS老是挂死的问题，学习了一下JAVA多线程方面的知识，在此总结一下  1、在Java程序中，JVM负责线程的调度。线程调度是指按照特定的机制为多个线程分配CPU的使用权。  调度的模式有两种：分时调度和抢占式调度。分时调度是所有线程轮流获得CPU使用权，并平均分配每个线程占用CPU
Java多线程之线程安全问题
trong_ 的烂笔头
12-26 5677
Java多线程中的线程安全问题, 解决方法, 线程安全和不安全的标准类.
Java多线程
qq_34471880的博客
03-14 948
Java多进程,多线程编程,如何创建线程,线程启动中断等待,了解各种线程状态,线程安全以及如何解决线程安全问题,锁的作用,以及如何加锁,了解死锁怎么出现,如何解决死锁问题
java多线程常用的锁
AaronHyk的博客
09-28 1150
1. 悲观锁：当一天线程去获取锁之后，另一个线程来获取锁会阻塞等待，常见的synchronized就是悲观锁 2. 乐观锁：当一天线程去操作的时候，其他的线程也可以操作，操作提交是根据版本控制的，CAS就是乐观锁，通过比较预期值与实际值的比较考虑是否提交更新。悲观锁适合写场景多的情况，乐观锁适合读场景多的情况 3. 公平锁：所有线程都能公平的获取到锁，线程申请锁之后会排队到一个线程组里，根据申请顺序去获取锁的使用 4. 非公平锁：不是所有线程都能拿到锁，当一个线程去请求的时候可能直接插队拿到了锁，有一
JAVA多线程总结
一切总会归于平淡
03-20 1133
首先我们要知道进程是系统进行资源分配和调度的基本单位，而线程是进程的一个执行路径，一个进程中至少有一个线程，进程中的多个线程共享进程的资源。 我们之前启动程序执行后，main方法的执行其实就是一条单独的执行路径。
分享40个Java多线程问题小结
09-03
Java多线程是Java语言中一个重要的特性，它允许程序在同一时间执行多个任务，从而提高了系统的效率和资源利用率。在Java中，多线程可以通过两种主要方式实现：继承`Thread`类或实现`Runnable`接口。实现`Runnable`...
Java多线程通讯之wait,notify的区别详解
08-27
Java多线程通讯之wait、notify的区别详解 Java多线程通讯是指在多线程编程中，线程之间如何进行通讯和同步的问题。其中，wait和notify是两个非常重要的方法，用于控制线程的状态和同步。 wait方法： wait方法是...
Java创建多线程异步执行实现代码解析
08-18
Java多线程异步执行实现代码解析 Java语言中提供了多种方式来实现多线程异步执行，包括实现Runnable接口和继承Thread类两种方式。下面将对这两种方式进行详细的介绍和解析。 实现Runnable接口 实现Runnable接口是...
Java线程安全问题小结_动力节点Java学院整理
08-30
Java线程安全问题主要涉及到并发环境下多个线程对共享资源的访问和修改，这可能导致数据不一致、死锁等问题。Java内存模型（JMM）是Java语言为了保证跨平台的并发正确性而设定的一套规范，它规定了线程如何访问和...
Java-Lambda
最新发布
lizhiwei21的博客
07-21 201
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 564
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1178
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1158
JVM-垃圾回收与内存分配

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值