java-线程基础

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

文章目录

1-线程创建的三种方法

1-1.继承Thread类（重点）

创建步骤：

  1. 自定义线程类继承Thread类
  2. 重写Run()方法，编写线程方法体
  3. 创建线程对象，调用start()方法
public class ThreadTest {
    //下方创建了4个线程，4个线程不会共享100张票，每张票都会被打印4次，请看Runnable解决
    public static void main(String[] args) {
        //3.创建线程对象，调用start方法，这里创建了4个线程
        new TicketWindow().start();
        new TicketWindow().start();
        new TicketWindow().start();
        new TicketWindow().start();
    }
}
//1.自定义线程类继承Thread类
class TicketWindow extends Thread{
    private int tickets=100;
    @Override
    //2.重写run方法，编写方法体
    public void run(){
        while (true){
            if (tickets>0){
                System.out.println(Thread.currentThread().getName()+"正在发售第"+tickets--+"张票");
            }
        }
    }
}

局限性：

  • 自定义类要继承Thread，Java只支持单继承，万一student extends person，那么student类就没办法继承Thread，使用不了这种方法了，悲
  • 而且下方的代码中100张票是不被共享的，下方创建了4个线程，4个线程不会共享100张票，每张票都会被打印4次

1-2.实现Runnable接口（重点）

Runable接口内部只有一个抽象的run()方法

创建步骤：

  1. 定义MyRunnable类实现Runable接口
  2. 实现Run()方法，编写线程执行体
  3. 创建线程对象，使用new Thread()构造方法传入自定义类，同时参数2可以给个别名
public class RunnableTest {
    //只创建了一个自定义类，然后创建了4个线程，此时4个线程此时会共享100张票
    public static void main(String[] args) {
        //3.创建线程对象，使用new Thread()构造方法传入自定义类，同时参数2可以给个别名  
        TicketWindow2 tw2=new TicketWindow2();
        new Thread(tw2,"窗口1").start();
        new Thread(tw2,"窗口2").start();
        new Thread(tw2,"窗口3").start();
        new Thread(tw2,"窗口4").start();
    }
}
//1.定义自定义类实现Runable接口
class TicketWindow2 implements Runnable{
    private int tickets=10000;
    @Override
    //2.实现Run()方法，编写线程执行体
    public void run() {
        while (true){
            if (tickets>0){
                System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets--+"张票");
            }
        }
    }
}

1-3.实现Callable接口（了解）

创建步骤：

  1. 自定义类实现Callable接口
  2. 重写Call()方法
  3. 创建目标对象
  4. 使用futureTask构造方法
  5. 再使用Thread()构造方法再创建线程
public class CallableTest {
    public static void main(String[] args) {
        TicketWindow3 tw3=new TicketWindow3();
        //futuretask创建多少就是多少个线程
        FutureTask<Object> ft1=new FutureTask<Object>(tw3);
        FutureTask<Object> ft2=new FutureTask<Object>(tw3);
        FutureTask<Object> ft3=new FutureTask<Object>(tw3);
        FutureTask<Object> ft4=new FutureTask<Object>(tw3);
        new Thread(ft1,"窗口1").start();
        new Thread(ft2,"窗口2").start();
        new Thread(ft3,"窗口3").start();
        new Thread(ft4,"窗口4").start();
        //System.out.println(ft1.get());
    }
}
class TicketWindow3 implements Callable{
    private int tickets=100;
    @Override
    public Object call() throws Exception {
        while (true){
            if (tickets>0){
                System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets--+"张票");
            }
        }
    }
}

2-Run方法和Strat方法的区别

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pDCDoeFe-1626702069138)(04-线程.assets/image-20210414201823237.png)]

3-后台线程

  1. 为什么使用

    • 上方的例子中，main方法的代码执行完了，方法结束了，线程也会自动结束

    • main线程结束了，但是Java程序（进程）没有结束

    • 对Java程序来说只要有一个前台线程在运行，进程就不会结束，如果一个进程只有后台线程运行，这个进程就会结束

    • 前台线程与后台线程是相对概念，新创建的线程就是前台线程，一个线程在start方法执行前，setDaemon就会变成后台线程

  2. 使用方法

    • 在start()方法之前，使用setDaemon()方法设置一个后台线程即可，setDaemon(true)表示设置为后台线程
public class Example06 {
    public static void main(String[] args) {
        System.out.println("main线程是后台线程吗?" + Thread.currentThread().isDaemon());
        DamonThread dt = new DamonThread();
        Thread td = new Thread(dt, "线程/后台线程");
        System.out.println("thread线程默认是后台线程吗？" + td.isDaemon());
//        将线程td线程对象设置为后台线程
        td.setDaemon(true);
        System.out.println("thread线程默认是后台线程吗？" + td.isDaemon());
        td.start();
//        模拟主线程main的执行任务
        for (int i = 0; i < 5; i++) {
            System.out.println(i);
        }
    }
}
class DamonThread implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println(Thread.currentThread().getName() + "---在运行");
        }
    }
}

4-线程的调度，优先级

  1. 定义：

    线程优先级表示获得CPU的执行几率大小

  2. 使用方法

    • 在线程start()方法开启之前使用setPriority()方法传入整数即可，整数取值为1-10，越大几率越大
public class Example07 {
    public static void main(String[] args) {
        Thread thread1=new Thread(()->{
            for (int i=0;i<10;i++){
                System.out.println(Thread.currentThread().getName()+"正在输出i："+i);
        }
        });
        Thread thread2=new Thread(()->{
            for (int j=0;j<10;j++){
                System.out.println(Thread.currentThread().getName()+"正在输出j："+j);
        }
        },"优先级更高的线程");
	    //设置优先级（也是指概率）,通过setPriority()方法设置可以写入数字或者提供的常量
        thread1.setPriority(5);
	    //thread2获得运行的机会更大
        thread2.setPriority(10);
        thread1.start();
        thread2.start();
    }
}

5-线程休眠

  1. 定义

    人为控制线程，可以使当前在执行的线程暂停，进入休眠等待状态

  2. 使用方法：

    在start()方法之后，使用sleep()方法传入数字即可，单位为毫秒，如sleep(2000)，为休眠2秒

public class Example08 {
    public static void main(String[] args) {
        Thread thread1=new Thread(()->{
            for (int i=0;i<10;i++){
                System.out.println(Thread.currentThread().getName()+"正在输出i："+i);
                if (i==2){
                    try {
                        Thread.sleep(500);
                    }catch (Exception e){
                    }
                }
            }
        });
        Thread thread2=new Thread(()->{
            for (int j=0;j<10;j++){
                System.out.println(Thread.currentThread().getName()+"正在输出j："+j);
            }
        },"优先级更高的线程");
        thread1.start();
        thread2.start();
    }
}

6-线程让步

  1. 定义

    与sleep相似，让当前的正在运行的线程暂停，区别在yield()方法不会阻塞线程，而是处于就绪状态(与其他线程回到起跑线)，让系统重新调度一次，让步不一定成功，看CPU心情

  2. 使用方法

    yield()方法

public class Example09 {
    public static void main(String[] args) {
        Thread thread1=new YieldThread("thread1");
        Thread thread2=new YieldThread("thread2");
        thread1.start();
        thread2.start();
    }
}
class YieldThread extends Thread{
    public YieldThread(String name){
        super(name);
    }
    @Override
    public void run(){
        for (int i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+"----"+i);
            if (i==2){
			//yield方法会让优先级高于自己的先运行
                System.out.print("线程让步:");
                Thread.yield();
            }
        }
    }
}
/*
结果为：
thread1----0
thread1----1
thread1----2
线程让步:thread2----0
thread2----1
thread2----2
线程让步:thread1----3
thread1----4
thread2----3
thread2----4
分析：
看到线程1在i==2的时候让步了，然后线程2跑了，然后线程2跑到i==2又让步
*/

7-线程插队

  1. 插入某线程，使其阻塞，然后插入的线程运行完毕后，被插入的才能运行

  2. 使用在main线程中使用thread1.join()方法的线程，插进当前main线程中，thread1完全执行完毕后main才继续执行

  3. 使用方法

    在start之后，主要使用join()方法

public class Example10 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread1=new Thread(new EmergencyThread(),"thread1");
        thread1.start();
        for (int i=1;i<6;i++){
            System.out.println(Thread.currentThread().getName()+"输入："+i);
            if (i==2){
                //在main线程中调用thread1线程，使得thread1插队运行，main要等到thread1运行完再运行
                thread1.join();
            }
        }
//        thread1.start();
    }
}
class EmergencyThread implements Runnable{
    @Override
    public void run(){
        for (int i=1;i<6;i++){
            System.out.println(Thread.currentThread().getName()+"输入："+i);
        }
    }
}

8-多线程同步

限制某个资源(如：100张票)在同一时刻只能被一个线程访问

8.1-线程安全

问题引出：

结果会出现负数，主要是因为sleep，让其他的线程通过判断条件，进入了run方法内，这样的线程是不安全的，我们得想些方法去处理共享资源的代码同时只能有一个线程使用

public class Example11 {
    public static void main(String[] args) {
        TicketWindow ticketWindow = new TicketWindow();
        Thread thread1 = new Thread(ticketWindow, "thread1");
        Thread thread2 = new Thread(ticketWindow, "thread2");
        Thread thread3 = new Thread(ticketWindow, "thread3");
        Thread thread4 = new Thread(ticketWindow, "thread4");
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}

class TicketWindow implements Runnable {
    private int tickets = 100;

    @Override
    public void run() {
        while (true) {
            if (tickets > 0) {
                try {
                    Thread.sleep(100);
                }catch (Exception e){

                }
                System.out.println(Thread.currentThread().getName() + "出售第" + tickets-- + "张票");
            }
        }
    }
}
/*结果：出现负数，主要是因为sleep，让其他的线程通过判断条件，进入了run方法内
thread2出售第2张票
thread1出售第2张票
thread3出售第1张票
thread4出售第1张票
thread2出售第0张票
thread1出售第-1张票
*/

8.2-同步代码块

  1. 作用：

    使得共享资源的代码在任何时候只能有一个线程访问

  2. 使用方法：

    1. 随便定义一个对象，作为同步代码块的锁
    2. 将锁对象参数给同步代码块，且将关键代码放入同步代码块中
    //定义任意一个对象，用作同步代码块的锁
Object lock=new Object();
//lock参数是一个锁对象，默认锁对象标志位是1，此时线程可以进入运行，标志位变化为0，其他线程无法进入。待之前的线程出来后，标志位变为1，其他线程才可以进入哦
synchronized (lock){
	//关键代码存放位置
}

    示例代码如下：

public class Example12 {
    public static void main(String[] args) {
        SaleThread2 saleThread2=new SaleThread2();
        new Thread(saleThread2,"thread1").start();
        new Thread(saleThread2,"thread2").start();
        new Thread(saleThread2,"thread3").start();
        new Thread(saleThread2,"thread4").start();
    }
}
class SaleThread2 implements Runnable{
    private int tickets=100;
    //1.定义任意一个对象，用作同步代码块的锁
    Object lock=new Object();
    @Override
    public void run() {
        while (true){
            //2.锁对象放入，代码放入，nice！
            synchronized (lock){
                if (tickets>0){
                    try{
                        Thread.sleep(100);
                    }catch (Exception e){

                    }
                    System.out.println(Thread.currentThread().getName()+"正在发售第"+tickets--+"张票");
                }
            }
        }
    }
}

8.3-同步方法

  1. 定义：

    synchronized 返回值类型 方法名（参数 1，…）

    主要是使用synchronized修饰的方法，synchronized就是同步代码块使用的那个修饰符啦

  2. 作用：

    使得共享资源的代码在任何时候只能有一个线程访问

    synchronized修饰的方法，同时只允许一个线程访问，其他线程来的都会阻塞

  3. 使用方法：

    重写的run()方法里边的，有线程安全需求的方法，使用synchronized修饰就可以了，简单得一批

  4. 扩展思考：

    同步方法也有锁，它的锁就是当前调用该方法的对象，也就是this指向的对象，确保了唯一性

    静态方法的锁是该方法所在类的class对象，该对象可以使用"类名.class"取出

public class Example13 {
    public static void main(String[] args) {
        SaleThread3 saleThread3 = new SaleThread3();
        new Thread(saleThread3, "thread1").start();
        new Thread(saleThread3, "thread2").start();
        new Thread(saleThread3, "thread3").start();
        new Thread(saleThread3, "thread4").start();

    }
}

class SaleThread3 implements Runnable {
    private int tickets = 100;
    @Override
    public void run() {
        while (true) {
            sale();
        }
    }
    //这里就是核心了synchronized修饰的方法
    private synchronized void sale() {
        if (tickets > 0) {
            try {
                Thread.sleep(100);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "出售的票为第" + tickets-- + "张");
        }
    }
}

8.4-死锁问题

线程需要对方的锁，但是都拿不到，死锁就形成了

public class Example16 {
    public static void main(String[] args) {
        //线程1，flag为true，运行if中的内容
        DeadLockThread thread1 = new DeadLockThread(true);
        //线程2，flag为false，运行else中的内容
        DeadLockThread thread2 = new DeadLockThread(false);
        new Thread(thread1, "Chinese").start();
        new Thread(thread2, "American").start();
    }
}
class DeadLockThread implements Runnable {
    //定义两个类作为锁
    static Object chopsticks = new Object();
    static Object knifeAndFork = new Object();
    private boolean flag;
    //有参构造方法，给flag赋值
    DeadLockThread(boolean flag) {
        this.flag = flag;
    }
    @Override
    public void run() {
        if (flag) {
            while (true) {
                //线程1，不断循环，一直拿两个锁对象，运行
                synchronized (chopsticks) {
                    System.out.println(Thread.currentThread().getName() + "---if---chopsticks");
                    synchronized (knifeAndFork) {
                        System.out.println(Thread.currentThread().getName() + "---if---knifeAndFork");
                    }
                }
            }
        } else {
            while (true) {
                //线程2，受到影响，被线程1拿了锁对象，然后两个线程GG，死锁了
                synchronized (knifeAndFork) {
                    System.out.println(Thread.currentThread().getName() + "---else---knifeAndFork");
                    synchronized (chopsticks) {
                        System.out.println(Thread.currentThread().getName() + "---else---chopsticks");
                    }
                }
            }
        }
    }
}

8.5-同步锁

使用方法：

//1.定义一个Lock锁对象
private final Lock lock = new ReentrantLock();
//2.显示的加锁
lock.lock();
//这里就放你要锁住的代码部分
//3.解锁
lock.unlock();
//注意：一般配合try与catch，finally使用

示例：

public class Example14 {
    public static void main(String[] args) {
        LockThread lockThread=new LockThread();
        new Thread(lockThread,"thread1").start();
        new Thread(lockThread,"thread2").start();
        new Thread(lockThread,"thread3").start();
        new Thread(lockThread,"thread4").start();
    }
}
class LockThread implements Runnable {
    private int tickets = 100;
    //定义一个Lock锁对象
    private final Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            //对代码块进行加锁
            lock.lock();
            if (tickets > 0) {
                try {
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets--+"张票");
                } catch (Exception e) {
                    e.printStackTrace();
                }finally {
                    //执行完代码块后释放锁
                    lock.unlock();
                }
            }
        }

    }
}

9-多线程通信

线程与线程之间的通信问题，比如生产者和消费者相互通信

以下方法一般用作线程通信，且是"锁对象.方法"：

  • wait()方法：使当前线程放弃同步锁并进入等待，直到其他线程进入此同步锁，并调用notify()方法，或者notifyAll()方法唤醒线程为止。wait()会释放锁，sleep()不会释放锁
    • 传入参数，可以指定等待秒数
    • 不传参数，线程一直等待，直到其他线程通知
  • notify()方法：唤醒此同步锁上等待的第一个调用wait()方法的线程
  • notifyAll()方法：唤醒此同步锁上调用的wait()方法的所有线程

问题引入，未使用线程通信：

/**
 * 问题就是供求关系不匹配，生产和消费对不上，这时候就需要用线程通信
 */
public class Problem {
    public static void main(String[] args) {
        //定义商品
        List<Object> goods = new ArrayList<>();
        long start = System.currentTimeMillis();
        //定义线程1，来生产商品
        Thread thread1 = new Thread(() -> {
            int num = 0;
            while (System.currentTimeMillis()-start<=100){
                goods.add("商品" + ++num);
                System.out.println("生产商品"+num);
            }
        },"生产者");
         //定义线程2，来消费商品
        Thread thread2 = new Thread(() -> {
            int num = 0;
            while (System.currentTimeMillis()-start<=100){
                goods.remove("商品"+ ++num);
                System.out.println("消费商品"+num);
            }
        },"生产者");
//        定义了两个线程，分别是消费者和生产者，同时运行100毫秒，看看供求关系
        thread1.start();
        thread2.start();
    }
}
//结果：生产和消费不能够统一，有时候才生产1000个东西，消费都达到1200了，显然离谱，虚空来的200个

现在使用线程的通信，解决问题：

public class Solve {
    public static void main(String[] args) {
        List<Object> goods = new ArrayList<>();
        long start = System.currentTimeMillis();
        //线程1，来生产商品
        Thread thread1 = new Thread(() -> {
            int num = 0;
            while (System.currentTimeMillis() - start <= 100) {
                //使用goods作为锁对象
                synchronized (goods) {
                    //有商品就让生产者进入等待状态
                    if (goods.size() > 0) {
                        try {
                            goods.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    } else {
                        goods.add("商品" + ++num);
                        System.out.println("生产商品" + num);
                    }
                }
            }

        }, "生产者");
        Thread thread2 = new Thread(() -> {
            int num = 0;
            while (System.currentTimeMillis() - start <= 100) {
                //使用goods作为锁对象
                synchronized (goods) {
//                    商品不足就唤醒生产者生产
                    if (goods.size() <= 0) {
                        goods.notify();
                    } else {
                        goods.remove("商品" + ++num);
                        System.out.println("消费商品" + num);
                    }
                }

            }
        }, "生产者");
//        定义了两个线程，分别是消费者和生产者，同时运行100毫秒，看看供求关系
        thread1.start();
        thread2.start();

    }
}
Lemonyuki
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java笔记 - 线程基础知识
yansha的专栏
04-05 4455
进程是一个执行中程序的实例，是操作系统进行资源分配和调度的一个独立单元。线程是进程中一个单一的程序控制流，是 CPU 调度和分派的基本单元。进程在执行时拥有独立的内存空间，进程中的线程可以共享进程的内存空间。在 Java 的世界中，进程可以拥有多个并发执行的线程，多线程是实现并发任务的方式。
JAVA-多线程 所有文件
01-09
4. **线程状态**：Java线程有五种状态：新建、就绪、运行、阻塞和终止。了解这些状态有助于理解线程的生命周期。 5. **同步机制**：Java提供了多种同步机制防止数据竞争，如`synchronized`关键字、`wait()`, `...
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6249
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 15万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java中的线程基础篇-线程基本概念
weixin_44446626的博客
05-08 1803
Java中的线程一、基础知识1. 进程、线程、协程1.1 进程1.2 线程1.3 协程2. 串行、并发、并行2.1 串行2.2 并发2.3 并行二、线程的创建1. 继承Thread类1.1 实现步骤1.2 特点2. 实现Runnable接口2.1 实现步骤2.2 与Thread相比3. 实现Callable接口（JDK5.0新增）3.1 实现步骤3.2 与Runnable接口相比三、线程的常用方法四、线程的生命周期1. 基本概念2. 六个状态 一、基础知识 1. 进程、线程、协程 1.1 进程 基本概念
6-3 jmu-Java-07多线程-同步访问
cTiebo的博客
11-04 1238
jmu-Java-07多线程-同步访问
Java高级特性 - 多线程基础（1）使用线程
weixin_62440328的博客
11-25 1131
【代码】Java高级特性 - 多线程基础（1）使用线程。
6-6 jmu-Java-07多线程-同步访问 (10 分)
m0_54524462的博客
12-02 3249
6-6 jmu-Java-07多线程-同步访问 (10 分) 现已有Account类，拥有 属性: private int balance 方法: 相应的getter方法。 要求为该类编写： void deposit(int money) //存钱，在余额的基础上加上money void withdraw(int money) //取钱，在余额的基础上减去money 注意： 取钱时如果balance<0的时候，会抛出异常。在多线程情况下，如只有一个存钱的线程，但是有多个取钱的线程，很可能会抛出异常。
java线程阻塞的原因_java 基础--线程阻塞的原因
weixin_30629043的博客
02-13 2935
1. 线程在运行的过程中因为某些原因而发生阻塞，阻塞状态的线程的特点是：该线程放弃CPU的使用，暂停运行，只有等到导致阻塞的原因消除之后才回复运行。或者是被其他的线程中断，该线 程也会退出阻塞状态，同时抛出InterruptedException。 导致阻塞的原因有很多种，大致分为三种来讨论，分别是一般线程中的阻塞，Socket客户端的阻塞，Socket服务器端的阻...
jmu-Java-07多线程-互斥访问
qq_hua_xia的博客
10-27 2143
题目详情： 6-2 jmu-Java-07多线程-互斥访问 (10 分) 定义Account类属性：private int balance方法： getter方法void deposit(int money)//存钱，在余额的基础上加上moneyvoid withdraw(int money)//取钱，在余额的基础上减去money 注意：可能有多个线程通过deposit或withdraw方法同时存取Account对象的balance属性。 裁判测试程序： import java.util.S..
Java - 多线程
了解➔熟悉➔掌握➔精通
03-23 3万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 引 如果对什么是线程、什么是进程仍存有疑惑，请先Google之，因为这两个概念不在本文讨论的范围之内。 用多线程只有一个目的，那就是更好的利用CPU的资源，因为所有的多线程代码都可以用单线程来实现。说这个话其实只有一半对，因为反应”多角色”的程序...
java-java面试题库整理-基础-JVM-线程并发-框架等.zip
02-06
这份"java-java面试题库整理-基础-JVM-线程并发-框架等.zip"文件提供了一个全面的复习资源，帮助求职者准备Java相关的面试。 1. **Java基础知识** - 类与对象：Java是一种面向对象的语言，了解类的定义、构造器、...
Java 多线程与并发(2-26)Java 并发 - 线程基础.pdf
07-14
线程基础是理解并发编程的关键，它涉及到线程的状态转换、创建与使用方式、同步与协作机制等方面。 线程有五种基本状态： 1. 新建（New）：线程被创建但尚未启动。 2. 可运行（Runnable）：线程可能正在运行，也...
java并发编程专题（一）----线程基础知识
08-18
Java并发编程专题（一）----线程基础知识 本文主要介绍了Java并发编程线程的基础知识，旨在帮助大家更好地学习JAVA并发编程。下面将详细讲解线程的基础知识。 一、线程的状态 在Java中，线程的状态可以分为五种：...
java线程基础
12-21
Java线程基础是Java编程中不可或缺的一部分，尤其在开发高并发和实时响应的应用时更为重要。线程允许程序同时执行多个任务，提高了程序的效率和响应速度。 **应用程序与进程** 应用程序是用户可以执行的软件实例，...
Java-Lambda
最新发布
lizhiwei21的博客
07-21 333
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 568
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1187
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1178
JVM-垃圾回收与内存分配
Java多线程基础与实战
本文旨在介绍Java多线程的基础知识，包括线程的实现方式、线程同步以及线程状态等核心概念。" 在Java中，线程是一个程序执行的最小单元，它代表了进程中的单一控制流。与进程相比，线程更加轻量级，因为它们共享...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值