Java多线程

最新推荐文章于 2024-07-19 17:37:28 发布
最新推荐文章于 2024-07-19 17:37:28 发布
阅读量132 收藏
点赞数 1
分类专栏： Java基础知识 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/char_shuai/article/details/115674325
版权

基本概念

程序： 是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
进程： 是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程。进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。
线程： 进程可进一步细化为线程，是一个程序内部的一条执行路径。若一个进程同一时间并行执行多个线程，就是支持多线程的。线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器。一个进程中的多个线程共享相同的内存单元/内存地址值—>他们从同一堆中分配对象，可以访问相同的变量和对象。
注： 一个Java.exe至少拥有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。
并行： 多个CPU同时执行多个任务。比如：多个人同时做不同的事。
并发： 一个CPU（采用时间片）同时执行多个任务。

线程的状态及其转换

线程状态

新建状态（NEW）
  用new语句创建的状态就处于新建状态，和Java对象一样，在堆中分配了内存，在调用start（）之前，就处于新建状态
就绪状态（RUNNABLE）
  在一个线程对象创建之后，调用start（）方法，该线程就进入就绪状态。JVM为线程创建栈和程序计数器。处于这个状态的线程位于可运行池中，等待获取CPU的执行权。
运行状态（RUNNING）
  处于该状态的线程获取了CPU的执行权，执行程序代码，只有处于就绪状态的线程才有机会到运行状态。
阻塞状态（BLOCKED）
  在线程期望进入同步代码块或者同步方法中时，会进入该状态。等待资源（非CPU资源）。
等待状态（WAITING）
  一般调用wait()方法会进入等待状态，当线程被其他的notify或者notifyAll的线程通知唤醒，才会从等待状态进入阻塞状态（还需要获取锁）
超时等待（TIMED-WAITING）
  如果线程执行了sleep（），wait（），join（），设置等待时间，当设定的等待时间到了，就会脱离超时状态
终止状态（TERMINATED）
  线程退出run（）时，就进入终止状态，该线程结束了生命周期

线程状态的转换

多线程的创建和启动

多线程的创建方式一：
* 1.创建一个继承于thread类的子类
* 2.重写thread类的run()，—>将此线程要执行的操作写在run()中。
* 3.创建thread类的子类的对象
* 4.通过此对象调用start()方法

public class ThreadTest {
    /**
     * 多线程的创建方式一：
     * 1.创建一个继承于thread类的子类
     * 2.重写thread类的run()，—>将此线程要执行的操作写在run()中。
     * 3.创建thread类的子类的对象
     * 4.通过此对象调用start()方法
     * <p>
     * 例子：遍历100以内的所有偶数
     *
     * @param args
     */
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();

        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i + "*****");
            }
        }
    }
}
 class MyThread extends Thread{
    @Override
    public void run() {
        for(int i = 0;i < 100;i++){
            if (i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}

多线程的创建方式二：实现Runnable接口的方式

  • 1、创建一个实现了Runnable接口的类
  • 2、实现类去实现Runable中的抽象方法：run()
  • 3、创建实现类的对象
  • 4、将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
  • 5、通过Thread类的对象调用start（）
package com.company;
/*创建多线程的第二种方式：实现Runnable接口的方式
 *1、创建一个实现了Runnable接口的类
 * 2、实现类去实现Runable中的抽象方法：run()
 * 3、创建实现类的对象
 * 4、将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
 * 5、通过Thread类的对象调用start（）
 *
 *
 */

class MThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }

        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        //创建实现类的对象
        MThread m = new MThread();
        //将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t = new Thread(m);
        //通过Thread类的对象调用start()①启动线程②调用当前线程的run()--->调用了Runnable类型的target的run()
        t.setName("线程一");
        t.start();

        //再启动一个线程
        Thread t2 = new Thread(m);
        t2.setName("线程二");
        t2.start();
    }
}

比较两种创建线程的方式

开发中优先选择实现Runnable接口的方式
原因： ①实现的方式没有类的单继承性的局限性
②实现的方式更适合来处理多个线程有共享数据的情况
联系： public class Thread implements Runnable
相同点： 两种方式都需要重写run()，将线程要执行的逻辑声明在run()中

Thread中的常用方法

1.start():启动当前线程，调用当前线程的run()
2.run():通常需要重写thread类中的此方法，将创建的线程执行的操作声明在此方法中。
3.currentThread():静态方法，返回执行当前代码的线程
4.getName():获取当前线程的名字。
5.setName():设置当前线程的名字。
6.yield():一旦线程执行此方法时,将会释放当前CPU的执行权。
7.join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，知道线程b完全执行完以后，线程a才结束阻塞状态。
8.stop():强制结束当前线程，已过时。
9.sleep(long milltime):让当前线程”睡眠“指定的milltime毫秒，在指定的milltime毫秒时间内，当前线程是阻塞状态。
10.isAlive():判断当前线程是否存活。

线程的调度

调度策略

时间片：
在这里插入图片描述
抢占式： 高优先级的线程抢占CPU

调度方法

同优先级线程组成队列（先到先服务），使用时间片策略。
对于高优先级的线程来说则使用优先调度的抢占式策略。

线程的优先级

优先级高的线程并不一定会先执行，只是执行的几率的高。
等级：
最高级：MAX—PRIORITY：10
最低级：MIN—PRIORITY：1
默认：NORM—PRIORITY：5
获取和设置当前线程的优先级：
getPriority():获取当前线程的优先级
setPriority():设置线程的优先级

线程安全问题的解决

方式一： 同步代码块
synchronized(同步监视器){
//需要被同步的代码
}

/*
 * 例子：创建三个窗口卖票，总票数为100张
 *同步代码块
 * synchronized(同步监视器){
 * //需要被同步的代码
 * }
 *
 */
class Window implements Runnable{//使用继承的方式来实现线程安全时
//必须将对象设置为static才能保证锁是唯一的。
    private static  int ticket = 100;
    //new一个对象来充当同步监视器，并且多个线程要共用同一把锁。
    Object obj = new Object();
    @Override
    public void run() {
            while (true) {
                synchronized (obj) {//放入需要被同步的代码，即操作共享数据的代码
                //当使用实现类的方式时，可以将对象换成this，表示实现类的对象
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + ":票号为" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}
public class WindowTest {
    public static void main(String[] args) {
        Window w1 = new Window();
      Thread t1 = new Thread(w1);
      t1.start();
        Thread t2 = new Thread(w1);
        t2.start();
        Thread t3 = new Thread(w1);
        t3.start();
    }
}

说明 ：操作共享数据的代码，即为需要被同步的代码。
共享数据： 多个线程共同操作的变量。
同步监视器： 俗称：锁，任何一个类的对象，都可以充当锁。要求：多个线程必须要共用同一把锁。
补充： 在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器
方式二： 同步方法
如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明为同步的。
使用同步方法来实现Runnable接口的线程安全问题

public class WindowTest2 {
    public static void main(String[] args) {
        WindowTest2_1 windowTest2_1 = new WindowTest2_1();
        Thread t1 = new Thread(windowTest2_1);
        t1.start();
        Thread t2 = new Thread(windowTest2_1);
        t2.start();
    }

}

class WindowTest2_1 implements Runnable{
    private int ticket = 100;
    @Override
    public void run() {
        while (true){
            show();
        }

    }
//使用同步方法解决线程安全问题
    private synchronized void show(){//同步监视器是this
        if (ticket > 0){
            System.out.println(Thread.currentThread().getName()+":" + ticket);
            ticket--;
        }

        }
    }

使用同步方法来继承Thread类解决线程安全问题

public class WindowTest3 {
    public static void main(String[] args) {
        WindowTest3_1 windowTest3_1 = new WindowTest3_1();
        windowTest3_1.start();
        WindowTest3_1 windowTest3_11 = new WindowTest3_1();
        windowTest3_11.start();
    }
}

class WindowTest3_1 extends Thread{
    private static int ticket = 100;

    @Override
    public void run() {
        while (true){
            show();
        }

    }
/*
  *@Description: 此时的同步监视器为WindowTest3_1.class
  *@Param: 
  *@return:  
  *@Author: 张帅
  *@Date: 2021/4/17 10:12
 **/

    private static synchronized void show(){
        if(ticket > 0){
            System.out.println(Thread.currentThread().getName() + ":" + ticket--);
        }
    }
}

总结：
①同步方法仍然要用到同步监视器，只是我们不需要显式的声明。
②非静态的同步方法：同步监视器是：this 静态的同步方法：同步监视器是当前类本身。
好处： 同步的方式，解决了线程的安全问题
缺点： 操作同步代码块时，只能有一个线程参与，其他线程等待，相当于是一个单线程的过程，效率低。

线程的死锁问题

死锁： 不同的线程分别占用对方需要的同步资源不放弃，都在等对方放弃自己需要的同步资源，就形成了线程的死锁。
出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
解决办法：

  • 专门的算法、原则
  • 尽量减少同步资源的定义
  • 尽量避免嵌套同步

Lock（锁）

java.util.concurrent.locks.Lock接口时控制多个线程对共享资源进行访问的工具，锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
基本步骤：
①实例化ReentrantLock
②调用锁定方法lock（）
③调用解锁方法：unlock（）


import java.util.concurrent.locks.ReentrantLock;

/**
 * @author ：ZS
 * @date ：Created in 2021/4/17 22:19
 * @description：${description}
 * @modified By：
 * @version: $version
 */
public class LockTest {
    public static void main(String[] args) {
        Window window = new Window();
        Thread t1 = new Thread(window);
        Thread t2 = new Thread(window);
        Thread t3 = new Thread(window);
        t1.setName("线程一");
        t2.setName("线程二");
        t3.setName("线程三");
        t1.start();
        t2.start();
        t3.start();
    }
}

class Window implements Runnable {
    private int ticket = 100;
    //1、实例化ReentrantLock
    private ReentrantLock reentrantLock = new ReentrantLock(true);

    @Override
    public void run() {
        while (true) {
            try {
                //2、调用锁定方法lock（）
                reentrantLock.lock();
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":票号为" + ticket--);
                } else {
                    break;
                }
            }finally {
                //3、调用解锁方法：unlock（）
                reentrantLock.unlock();
            }
        }
    }
}

synchronized与Lock的异同

相同点： 二者都可以解决线程安全问题
不同点： synchronized机制在执行完相应的同步代码块以后，自动的释放同步监视器，Lock机制需要手动的启动同步（lock()）,同时结束同步也需要手动的实现（unlock()）。
在这里插入图片描述

线程的通信

涉及到的方法：
wait():一旦执行此方法，当前线程就进入阻塞状态
notify()：一旦执行此方法，就会唤醒被wait()的一个线程，如果有多个线程，就会唤醒优先级高的那个线程
notifyAll():一旦执行此方法，就会唤醒所有被wait() 的线程

public class ThreadSignalingTest {
    public static void main(String[] args) {
        ThreadSignaling threadSignaling = new ThreadSignaling();
        Thread t1 = new Thread(threadSignaling);
        Thread t2 = new Thread(threadSignaling);
        t1.setName("线程一");
        t2.setName("线程二");
        t1.start();
        t2.start();
    }
}

class ThreadSignaling implements Runnable{
    private int number = 1;
    @Override
    public void run() {
        synchronized (this) {

            while (number <= 100) {
                //唤醒被阻塞的线程
                this.notify();
                if (number <= 100) {
                    System.out.println(Thread.currentThread().getName() + ":" + number++);
                }
                //使得当前线程进入阻塞状态
                try {
                    this.wait(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

说明：
①wait()、notify()、notifyAll()这三个方法必须使用在同步代码块或同步方法中。
②这三个方法的调用者，必须是同步代码块或同步方法中的同步监视器（同一个同步监视器），否则会出现IllegalMonitorStateException。
③wait()、notify()、notifyAll()这三个方法定义在java.lang.Object类中

sleep()和wait()的异同

相同点：
①一旦执行方法，都可以使得当前线程进入阻塞状态。
不同点：
①两个方法声明的位置不同：Thread类中声明sleep()，Object类中声明wait()。
②两个方法的使用要求不同：sleep()可以在任何需要的场景下调用，wait()必须使用在同步代码块或者同步方法中。
③关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。

释放锁的操作

在这里插入图片描述

不会释放锁的操作

在这里插入图片描述

JDK5.0新增线程创建方式

实现Callable接口

  • 1.创建一个实现Callable的实现类
  • 2.实现call方法，将此线程需要执行的操作声明在call()方法中
  • 3.创建Callable接口实现类的对象
  • 4.将此Callable接口实现类的对象传递到FutureTask构造器中，创建FutureTask的对象
  • 5.将FutureTask对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
  • 6.获取Callable中的call方法的返回值
package com.company;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @author ：ZS
 * @date ：Created in 2021/4/19 22:50
 * @description：通过实现Callable接口的方式实现多线程
 * @modified By：
 * @version: $version
 */
public class CallableTest {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        ThreadNumber threadNumber = new ThreadNumber();
        //4.将此Callable接口实现类的对象传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(threadNumber);
        //5.将FutureTask对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();
        try {
            //6.获取Callable中的call方法的返回值
            Object sum = futureTask.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
//1.创建一个实现Callable的实现类
class ThreadNumber implements Callable{
    //2.实现call方法，将此线程需要执行的操作声明在call()方法中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0){
                System.out.println(i);
                sum += i;
            }

        }
        return sum;
    }
}

优点： （与Runnable）相比

  • 与run()相比，可以有返回值
  • 方法可以抛出异常
  • 支持泛型的返回值
  • 需要借助Future Task类，比如获取返回结果
    如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
    ①call() 可以有返回值
    ②call（）方法可以抛出异常，被外面的操作捕获，获取异常的信息
    ③Callable是支持泛型的

使用线程池的方式实现多线程

1、提供指定线程数量的线程池
2、执行指定的线程的操作，需要提供实现Runnable接口或Callable接口的类的对象
3、关闭线程池
思路： 提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中，可以避免频繁创建销毁、实现重复利用。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author ：ZS
 * @date ：Created in 2021/4/20 22:43
 * @description：使用线程池实现多线程
 * @modified By：
 * @version: $version
 */
public class ThreadPool {
    public static void main(String[] args) {
        //1、提供指定线程数量的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service = (ThreadPoolExecutor) executorService;
        //设置线程池的属性,不能直接通过接口来设置属性，通过接口的实现类的对象来设置属性
        service.setCorePoolSize(15);
        service.setKeepAliveTime(15, TimeUnit.MILLISECONDS);
        //2、执行指定的线程的操作，需要提供实现Runnable接口或Callable接口的类的对象
        executorService.execute(new NumberThread());//适合使用于Runnable
//        executorService.submit();//适合使用于Callable
        //3、关闭线程池
        executorService.shutdown();//可以用来关闭线程池
    }
}


class NumberThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName() +":"+i);
            }
        }
    }
}

好处：
1、 提高响应速度（减少了创建新线程的时间）
2、 降低资源消耗（重复利用线程池中的线程，不需要每次都创建）
3、 便于线程管理

  • corePoolSize:核心池的大小
  • maximumPoolSize：最大线程数
  • keepAliveTime:线程没有任务时最多保持多长时间后会被终止
你在幹神魔
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JDK1.8 锁的实现与原理(一) 自己实现一个锁
m0_37407587的博客
02-15 1611
文章目录Java中的锁机制一个并发操作的Demo用atomic实现并发控制(无阻塞)用lock实现并发控制自己写一个实现`Lock`接口的类简述CAS无锁机制 Java中的锁机制 在学习Java的并发编程中, 锁机制是一个重点和难点, 在Java中并发常用到的锁相关的主要是synchronized关键字和java.util.concurrent.locks类, 两者的区别包括 synchroni...
Java多线程详解及示例
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
JUC并发编程笔记（狂神说）
THB66666的博客
09-24 452
JUC并发编程 狂神说：https://space.bilibili.com/95256449 1. 什么是JUC JUC就是java.util.concurrent下面的类包，专门用于多线程的开发。 源码 + 官方文档 面试高频问！ java.util 工具包 业务：无法通过普通的线程代码 Thread实现。 Runnable 没有返回值、效率相比于Callable相对较低！ 企业开发中Callable 使用较多 Callable ： 锁： 2、线程和进程 进程是操作系统中的应用程序、是资源
head first java中文电子版_Java 中队列同步器 AQS（AbstractQueuedSynchronizer）实现原理
weixin_39934869的博客
11-29 166
前言在 Java 中通过 锁 来控制多个线程对共享资源的访问，使用 Java 编程语言开发的朋友都知道，可以通过 synchronized 关键字来实现锁的功能，它可以隐式的获取锁，也就是说我们使用该关键字并不需要去关心锁的获取和释放过程，但是在提供方便的同时也意味着其灵活性的下降。例如，有这样的一个场景，先获取锁 A，然后再获取锁 B，当锁 B 获取到之后，释放锁 A 同时获取锁 C，当获取锁 ...
ReentrantLock
weixin_49561445的博客
10-03 229
特点 可中断 可以设置超时时间 可以设置为公平锁 (先到先得) 支持多个条件变量( 具有多个 WaitSet) 支持可重入 // 获取ReentrantLock对象 private ReentrantLock lock = new ReentrantLock(); // 加锁 lock.lock(); try { // 需要执行的代码 }finally { // 释放锁 lock.unlock(); } synchronized 和 ReentrantLock区别 Synchronize
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 15万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java多线程（超详细！）
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 41万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
【Java系列】深入解析Java多线程
颜淡慕潇
05-09 2万+
Java多线程是提高程序并发性和响应能力的重要手段，需要掌握多线程的实现方式、同步机制、线程之间的通信机制等，以确保多线程程序的正确性和稳定性。
Java多线程并发编程技术详解
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-20 1万+
Java多线程并发编程是一项需要深入理解和熟练掌握的技术，只有合理地设计和使用多线程，才能真正发挥其在提升系统性能方面的巨大潜力。随着对Java并发机制及工具类库的深入学习和应用，开发者可以更好地构建高效、稳定的并发系统。
java 多线程
11-07
java 多线程 知识相关，主要是介绍 java 多线程相关的知识
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
java多线程
05-02
Java多线程是Java编程中的核心概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，实现多线程有两种主要方式：通过实现`Runnable`接口和继承`Thread`类。 1. 实现Runnable接口 当一个类...
Java多线程读取大文件
12-22
【Java多线程读取大文件】是一种优化的文件处理策略，特别适用于处理大型文本文件。在传统的单线程I/O操作中，读取大文件可能导致内存溢出（OOM），尤其是在尝试一次性加载整个文件到内存时。为了避免这个问题，我们...
Java内存模型
最新发布
weixin_44267758的博客
07-19 329
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 630
JVM-垃圾回收与内存分配
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 870
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
【Java算法】前缀和 下
2302_79806056的博客
07-18 917
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值