Java-多线程

已于 2022-09-09 19:30:04 修改
阅读量756 收藏 1
点赞数 1
分类专栏： Java基础 java学习 文章标签： java jvm 开发语言
于 2022-09-09 19:29:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_52166656/article/details/126788251
版权

文章目录

Java—多线程

1.0进程与线程概念

进程就是程序的第一次动态过程，它需要经历从代码加载、代码执行到执行完毕的一个完整过程，这个过程也是进程本书从产生、发展到最后消亡的过程。

多线程是实现并发机制的一种有效的手段，进程和线程都一样，都是实现并发的一个基本单位，线程是比进程更小的执行单位，所谓的多线程是指一个进程在执行过程中可以产生多个更小的程序单元。

所谓的线程(Thread)是指程序的运行流程，多线程机制可以同时运行多个程序块。

1.1Java中线程的实现

1.1.0继承Thread类

一个类只要继承了Thread类，此类就称为多线程实现类，在Thread子类中必须重写Thread类的run()方法，此方法为线程的主体。

public class MyThread extends Thread
{
    private String name;

    public MyThread(String name) {
        this.name = name;
    }
    public void run()
    {
        for (int i = 0; i < 10; i++) {
            System.out.println(name+"运行，i="+i);
        }
    }
}

//主方法测试类
public class ThreadDemo01
{
    public static void main(String[] args) {
        MyThread mt1=new MyThread("线程A");
        MyThread mt2=new MyThread("线程B");
        mt1.run();
        mt2.run();
    }
}

此时根据运行结果，此线程实际上没有被启动，还是属于顺序执行的方式。

要正确启动线程，不能直接调用run()方法，而是应该调用Thread类中继承来的start()方法。

//只需要在上面代码中修改，把run()方法改为start()方法即可

mt1.start();
mt2.start();

总结：在线程启动时虽然调用的是start()方法，但实际确是调用了run()方法的主体。

如果一个类通过继承的Thread类来实现，那么只能调用一次start()方法，如果调用多次则会抛出异常。

public class MyThread extends Thread
{
    private String name;

    public MyThread(String name) {
        this.name = name;
    }
    public void run()
    {
        for (int i = 0; i < 10; i++) {
            System.out.println(name+"运行，i="+i);
        }
    }
}

//主方法测试类
public class ThreadDemo01
{
    public static void main(String[] args) {
        MyThread mt1=new MyThread("线程A");
        mt1.start();
        mt1.start();
    }
}

如果一个类只能继承Thread类才能实现多线程，则必定会受到单继承局限的影响。一般来说，要想实现多线程还可以通过实现Runnable接口完成。

1.1.1实现Runnable接口

在java中可以通过Runnable接口方式实现多线程

public class MyThread implements Runnable
{
    private String name;

    public MyThread(String name) {
        this.name = name;
    }
    public void run()
    {
        for (int i = 0; i < 10; i++) {
            System.out.println(name+"运行，i="+i);
        }
    }
}

在Runnable接口中没有start()方法定义，要启动多线程，可以在Thread类中提供public Thread(Runnable target)和public Thread(Runnable target,String name)两个构造方法来实现多线程，这两个构造方法都可以接收Runnable的子类实例对象。

public class ThreadDemo01
{
    public static void main(String[] args) {
        //实例化Runnable的两个子类对象
        MyThread my1=new MyThread("线程A");
        MyThread my2=new MyThread("线程B");
        //实例化Thread对象
        Thread t1=new Thread(my1);
        Thread t2=new Thread(my2);
        t1.start();
        t2.start();
    }
}

也就是说不管用那种方式，用Thread继承也好，Runnable接口也好，最终都必须依靠Thread类才能启动多线程。

1.1.2Thread类和Runnable联系

看原始定义

public class Thread extends Object implements Runnable

从定义可以发现，Thread类也是Runnable接口的子类，但是在Thread类中没有实现Runnable接口中的run()方法

也就是说此方法是由Runnable子类完成的，所以如果要通过继承Thread类实现多线程，则必须重写run()方法。

一个类继承Thread类，则并不适用多个线城共享资源，请看下面例子

public class MyThread extends  Thread
{
    private int ticket=5;
    public void run()
    {
        for (int i = 0; i < 100; i++) {
            if(ticket>0)
            {
                System.out.println("卖票：ticket="+ticket--);
            }
                    }
    }
}

public class ThreadDemo01
{
    public static void main(String[] args) {
        //实例化Runnable的两个子类对象
        MyThread my1=new MyThread();
        MyThread my2=new MyThread();
        MyThread my3=new MyThread();

        my1.start();
        my2.start();
        my3.start();
    }
}

程序启动了3给线程，但是3给线程却分别卖各自5张票，没有达到资源共享的目的。

实现Runnable接口可以资源共享

public class MyThread implements Runnable
{
    private int ticket=5;
    public void run()
    {
        for (int i = 0; i < 100; i++) {
            if(ticket>0)
            {
                System.out.println("卖票：ticket="+ticket--);
            }
                    }
    }
}

public class ThreadDemo01
{
    public static void main(String[] args) {
        //实例化Runnable的两个子类对象
        MyThread my1=new MyThread();
        new Thread(my1).start();
        new Thread(my1).start();
        new Thread(my1).start();
    }
}

从程序运行结果可以清除发现，虽然启动了3给线程，但是3给线程一共才执行了5张票，即ticket属性被所以的线程对象共享。

实现Runnable接口相对于继承Thread类来说，有一下的优势：

  • 适合多个相同的程序代码线程去处理统一资源情况
  • 可以避免由于java的单继承特性的局限性
  • 代码可以被多个线程共享，代码与数据是独立的

1.2线程的状态

  • 运行状态

简单说就是创建了一个线程对象后，新的线程对象处于新建状态，例如：Thread thread=new Thread()

  • 就绪状态

当线程启动时，线程就进入就绪状态，例如调用线程中的start()方法，此时线程进入队列排队，等待CPU的服务

  • 堵塞状态

当就绪状态的线程被调用获得处理起资源时，线程就进入了运行状态，此时自动调用run()方法，run方法定义了该线程的操作和功能。

  • 死亡状态

线程调用stop()方法或run()方法执行结束后，就处于死亡状态，不在具有继续运行能力。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xABs6FAe-1662722798149)(C:\Users\13417\AppData\Roaming\Typora\typora-user-images\image-20220909192407056.png)]

1.3获得和设置线程的名称

在Thread类中可以通过getName()方法获得线程的名称，还可以通过setName()方法设置线程的名称。需要注意的是如果没有设置名称，系统会自动分配名称，格式为：Thread-Xx

public class MyThread implements Runnable
{
   public void run()
   {
       for (int i = 0; i < 3; i++) {
           System.out.println(Thread.currentThread().getName()+"运行，i="+i);
       }
   }
}

public class ThreadDemo01
{
    public static void main(String[] args) {
        //实例化Runnable的两个子类对象
        MyThread my1=new MyThread();
       new Thread(my1).start();
       new  Thread(my1,"线程-A").start();
       new  Thread(my1,"线程-B").start();
        new Thread(my1).start();
        new Thread(my1).start();
    }
}

可以看出没有设置线程名称都是很有规律的

在看一个例子

public class MyThread implements Runnable
{
   public void run()
   {
       for (int i = 0; i < 3; i++) {
           System.out.println(Thread.currentThread().getName()+"运行，i="+i);
       }
   }
}

public class ThreadDemo01
{
    public static void main(String[] args) {
        //实例化Runnable的两个子类对象
        MyThread my1=new MyThread();
       new Thread(my1,"线程").start();
       my1.run();
    }
}

可以看出其实主方法也是一个线程，在java中所有的线程都是同时启动的，哪个线程占到了CPU资源，哪个线程就可以先运行。

1.4判断线程是否启动

在前面可以知道，通过Thread类中的start()方法通知CPU这个线程已经准备好启动，等待CPU分配资源，运行此线程，在java中可以使用isAlive()方法来测试线程是否仍然在运行。

public class MyThread implements Runnable
{
   public void run()
   {
       for (int i = 0; i < 3; i++) {
           System.out.println(Thread.currentThread().getName()+"运行->>>"+i);
       }
   }
}


public class ThreadDemo01
{
    public static void main(String[] args) {
        //实例化Runnable的两个子类对象
        MyThread my1=new MyThread();
        Thread t=new Thread(my1,"线程");
        System.out.println("线程开始执行前>>>"+ t.isAlive());
        t.start();
        System.out.println("线程开始执行后>>>"+t.isAlive());
        for (int i = 0; i < 3; i++) {
            System.out.println("main运行->>>"+ i);
        }
        System.out.println("代码执行后>>>"+t.isAlive());
    }
}

以上输出结果是不确定的，有可能到最后线程已经不存活了，但也有可能继续存活，这就要看哪个线程先执行完。

1.5线程的强制执行

在线程操作中，可以使用join()方法让一个线程强制执行，线程运行期间，其他线程无法运行，必须等待此线程完成之后才可以继续执行。

public class MyThread implements Runnable
{
   public void run()
   {
       for (int i = 0; i < 3; i++) {
           System.out.println(Thread.currentThread().getName()+"运行->>>"+i);
       }
   }
}

public class ThreadDemo01
{
    public static void main(String[] args) {
        //实例化Runnable的两个子类对象
        MyThread my1=new MyThread();
        Thread t=new Thread(my1,"线程");
        t.start();
        for (int i = 0; i < 50; i++)
        {
            if(i>10){
                try {
                    t.join();
                }catch ( Exception e){}
            }
            System.out.println("Main线程运行->>>"+i);
        }

    }
}

可以知道所有的输出都将由一个线程来完成，主线程必须等待这个线程。

1.6线程的休眠

在一个程序中允许一个线程暂时的休眠，直接使用Thread.sleep()方法即可实现休眠。

public class MyThread implements Runnable
{
   public void run()
   {
       for (int i = 0; i < 5; i++)
       {
           try
           {
               //休眠500ms
               Thread.sleep(500);
           }catch (Exception e){}
           System.out.println(Thread.currentThread().getName()+"运行,i="+i);
       }
   }
}

public class ThreadDemo01
{
    public static void main(String[] args) {
        //实例化Runnable的两个子类对象
        MyThread my1=new MyThread();
        new Thread(my1,"线程").start();
    }
}

在上面程序中每次输出都会间隔500ms达到了延迟操作的效果。

1.7中断线程

当一个线程运行时，另外一个线程可以直接通过interrupt()方法中断其运行状态。

public class MyThread implements Runnable
{
   public void run()
   {

       System.out.println("1、进入run方法");
       {
           try
           {
               //休眠500ms
               Thread.sleep(10000);
               System.out.println("2、已经完成休眠");
           }catch (Exception e)
           {
               System.out.println("3、休眠被终止");
               return;
           }
           System.out.println("4、run方法正常结束");
       }
   }
}


public class ThreadDemo01
{
    public static void main(String[] args) {
        //实例化Runnable的两个子类对象
        MyThread my1=new MyThread();
        Thread t = new Thread(my1,"线程");
        t.start();
        try
        {
            Thread.sleep(1200);
        }catch (Exception e)
        {
        }
        t.interrupt();

    }
}

1.8后台线程

在Java程序中，只要前台有一个线程在运行，整个java进程都不会消失，所以此时可以设置一个后台线程，这样即使java进程结束了，此后台线程依然会继续执行。使用setDaemom()方法

public class MyThread implements Runnable
{
   public void run()
   {
       while(true)
       {
           System.out.println(Thread.currentThread().getName()+"在运行");
       }
   }
}

public class ThreadDemo01
{
    public static void main(String[] args) {
        //实例化Runnable的两个子类对象
        MyThread my1=new MyThread();
        Thread t = new Thread(my1,"线程");
        t.setDaemon(true);
        t.start();
    }
}

尽管run()方法是死循环的方式，但是程序依然可以执行完，因为方法中死循环的线程操作已经设置为后台运行了。

1.9线程的优先级

在java的线程中使用setPriority()方法可以设置一个线程优先级，在Java线程中一共有三种优先级

public class MyThread implements Runnable
{
   public void run()
   {
       for (int i = 0; i < 5; i++) {
           try
           {
               Thread.sleep(500);
           }catch (Exception e)
           {

           }
           System.out.println(Thread.currentThread().getName()+"运行,i="+i);
       }
   }
}

public class ThreadDemo01
{
    public static void main(String[] args) {
        Thread t1=new Thread(new MyThread(),"线程A");
        Thread t2=new Thread(new MyThread(),"线程B");
        Thread t3=new Thread(new MyThread(),"线程C");
        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.MAX_PRIORITY);
        t3.setPriority(Thread.NORM_PRIORITY);
        t1.start();
        t2.start();
        t3.start();
    }
}

线程根据其优先级的大小决定哪个线程会先运行，但是并非线程的优先级越高就一定会先执行，哪个线程先执行将由CPU调度决定。

2.0线程的礼让

在线程操作中，可以使用yield()方法将一个线程的操作暂时让给其他线程执行。

public class MyThread implements Runnable
{
   public void run()
   {
       for (int i = 0; i < 5; i++) {
           System.out.println(Thread.currentThread().getName()+"运行->>>"+i);
        if(i==3)
        {
            System.out.println("线程礼让：");
            Thread.currentThread().yield();
        }
       }
   }
}

public class ThreadDemo01
{
    public static void main(String[] args) {
        Thread t1=new Thread(new MyThread(),"线程A");
        Thread t2=new Thread(new MyThread(),"线程B");
        t1.start();
        t2.start();
    }
}

2.1线程操作范例

2.2同步与死锁

现在通过Runnable接口实现多线程，并产生3给线程对象，同时卖5张票。

public class MyThread implements Runnable
{
    private int ticket=5;
   public void run()
   {
       for (int i = 0; i < 100; i++) {
           if(ticket>0)
           {
               try
               {
                   Thread.sleep(300);
               }catch (InterruptedException e)
               {
                   e.printStackTrace();
               }
               System.out.println("卖票：ticket="+ticket--);
           }
       }
   }
}


public class ThreadDemo01
{
    public static void main(String[] args) {
        MyThread mt=new MyThread();
        Thread thread1=new Thread(mt);
        Thread thread2=new Thread(mt);
        Thread thread3=new Thread(mt);
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

从程序运行结果可以发现，程序加入延迟操作，但是在程序最后出现负数的情况，原因是在一个线程还没在对票数相减时，其他线程就已经把票数相减了。

2.3使用同步解决问题

所谓的同步就是多个操作在同一时间段内只能有一个线程进行，其他线程需要等待，解决资源共享的同步操作，可以使用同步代码块和同步两种方法完成。

使用同步代码块解决同步的问题

public class MyThread implements Runnable
{
    private int ticket=5;
   public void run()
   {
       for (int i = 0; i < 100; i++) {
          synchronized (this){
           if(ticket>0)
           {
               try
               {
                   Thread.sleep(300);
               }catch (InterruptedException e)
               {
                   e.printStackTrace();
               }
               System.out.println("卖票：ticket="+ticket--);
           }
          }
       }
   }
}


public class ThreadDemo01
{
    public static void main(String[] args) {
        MyThread mt=new MyThread();
        Thread thread1=new Thread(mt);
        Thread thread2=new Thread(mt);
        Thread thread3=new Thread(mt);
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

同步方法

public class MyThread implements Runnable
{
    private int ticket=5;
   public void run()
   {
       for (int i = 0; i < 100; i++) {
           this.sale();
       }
   }
       public synchronized void sale()
   {
       if(ticket>0)
       {
           try
           {
               Thread.sleep(300);
           }catch (InterruptedException e)
           {
               e.printStackTrace();
           }
           System.out.println("卖票：ticket="+ticket--);
       }
   }

}
public class ThreadDemo01
{
    public static void main(String[] args) {
        MyThread mt=new MyThread();
        Thread thread1=new Thread(mt);
        Thread thread2=new Thread(mt);
        Thread thread3=new Thread(mt);
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

此代码块完成了之前同步代码块同样的功能

2.4死锁

死锁就是指两个线程都在等待对方先完成，造成了程序的停滞，一般程序死锁都是在程序运行时候出现的。

public class List
{
    public void say()
    {
        System.out.println("李四对张三说：你给书，我就把画给你");
    }
    public void get()
    {
        System.out.println("李四得到书了");
    }
}
public class Zhangsan
{
    public void say()
    {
        System.out.println("张三对李四说：你给画，我就把书给你");
    }
    public void get()
    {
        System.out.println("张三得到画了");
    }
}
public class ThreadDead implements Runnable
{
    private static Zhangsan zs=new Zhangsan();
    private static List is=new List();
    public boolean flag=false;
    public void run() {
        if (flag) {
            synchronized (zs) {
                zs.say();
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (is) {
                    zs.get();
                }
            }
        } else {
            synchronized (is) {
                is.say();

                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (zs) {
                    is.get();
                }
            }
        }
    }
}

public class Test
{
    public static void main(String[] args) {
        ThreadDead t1 = new ThreadDead();
        ThreadDead t2 = new ThreadDead();
        t1.flag=true;
        t2.flag=false;
        Thread thA=new Thread(t1);
        Thread thB=new Thread(t2);
        thA.start();
        thB.start();
    }
}

从程序可以发现，两个线程都在彼此等待着对方的执行完成，这样，程序无法继续下去执行，从而造成死锁的状态。

2.5线程的生命周期

在java中一个线程对象都有自己的生命周期，如果要控制线程的生命周期，首先要认识生命周期。

对于线程中的suspend()/stop()/resume() 3种方法并不推荐使用，因为可能回产生死锁的问题。

6-1 jmu-Java-07多线程-Thread (20分)
sddfnsff的博客
05-26 6256
编写MyThread类继承自Thread。创建MyThread类对象时可指定循环次数n。 功能：输出从0到n-1的整数。 并在最后使用System.out.println(Thread.currentThread().getName()+" "+isAlive())打印标识信息 裁判测试程序： import java.util.Scanner; /这里放置你的答案，即MyThread类的代码/ public class Main { public static void main(String[] args
Java-多线程线程状态转换图
07-22
多线程线程状态转换图
Java - 多线程
热门推荐
了解➔熟悉➔掌握➔精通
03-23 3万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 引 如果对什么是线程、什么是进程仍存有疑惑，请先Google之，因为这两个概念不在本文讨论的范围之内。 用多线程只有一个目的，那就是更好的利用CPU的资源，因为所有的多线程代码都可以用单线程来实现。说这个话其实只有一半对，因为反应”多角色”的程序...
java-多线程编程
weixin_53700016的博客
04-18 2414
1、基本概念 程序：是为了完成某特定任务，用某语言编写的一组指令的集合。 进程：是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位。 线程：是进程中的一个实体，作为系统调度和分派的基本单位。 一个java程序的正常运行，至少需要三个线程。（main主线程、gc垃圾回收线程、议程处理线程） 并行：多个CPU同时执行多个任务。 并发：一个CPU采用时间片的方法同时执行多个任务 2、线程的状态 新建（New）：在程序中用构造方法创建一个线程对象后，新的线程对象便
12jmu-Java-07多线程-Thread
ihopeyousuccess的博客
11-30 2420
编写MyThread类继承自Thread。创建MyThread类对象时可指定循环次数n。 功能：输出从0到n-1的整数。 并在最后使用System.out.println(Thread.currentThread().getName()+" "+isAlive())打印标识信息 裁判测试程序： import java.util.Scanner; /这里放置你的答案，即MyThread类的代码/ public class Main { public static void main(String[] args
java ----多线程题目汇总
qq_38345598的博客
05-03 2209
1、请问 如何控制多线程顺序执行 1、使用join 控制 package com.example.demothread.util; import lombok.extern.slf4j.Slf4j; import org.springframework.web.bind.annotation.PathVariable; /** * @author lenovo * @version 1.0 * @Date 2022/5/3 12:22 * @Description */ @Sl...
Java-多线程中的“锁“
向诸位大佬虚心学习
07-22 2251
锁是一种同步机制，它可以让多个线程按照一定的顺序访问共享资源。在Java中，锁可以是隐式的，也可以是显式的。隐式锁：通过关键字来实现，它可以用于修饰方法或代码块。当一个线程进入被修饰的方法或代码块时，它会自动获取锁，并在执行完毕后释放锁。显式锁：通过包中的Lock接口及其实现类来实现，如ReentrantLock。显式锁需要手动获取和释放，在使用上更加灵活。锁是Java多线程编程中重要的同步机制，用于保护共享资源的访问。它可以解决竞态条件、临界区和死锁等问题。
Java--多线程之并发，并行，进程，线程（一）
MinggeQingchun的博客
03-12 3078
以下对并发、并行、进程、线程的理解引自 阿里巴巴技术专家Hollis Java并发编程 一、并发 并发（Concurrent），在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。 无论是Windows、Linux还是MacOS等其实都是多用户多任务分时操作系统。使用这些操作系统的用户是可以“同时”干多件事的 二、并行 并行（Parallel），当系统有一个以上CPU时，当一个CPU执行一个进程时，另一个CPU可以执行另一个进程，两个进.
jmu-Java-07多线程-Runnable与匿名类
qq_hua_xia的博客
10-27 1360
题目详情： 6-1 jmu-Java-07多线程-Runnable与匿名类 (10 分) 在Main方法中启动一个线程t1，该线程输出3行信息： 主线程名 线程t1的线程名 线程t1所实现的所有接口。提示：使用System.out.println(Arrays.toString(getClass().getInterfaces()));输出。 注：本题也可使用Lambda表达式实现。 裁判测试程序： public class Main { public static void
Java-多线程基本方法
PreyHard的博客
11-13 1662
一.什么是进程 （一）线程和进程 要想说线程，首先必须得聊聊进程，因为线程是依赖于进程存在的。 （二）进程概述 进程就是正在运行的程序，是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源。 二.多线程的意义 多线程的作用不是提高执行速度，而是为了提高应用程序的使用率。 ------那么怎么理解这个问题呢? ------我们程序在运行的使用,都是在抢CPU的时间片(执行权)...
Java笔记-多线程相关
IT1995的博客
12-27 4939
ava多线程和C++里面的多线程有些地方不一样。 毕竟套了一个java虚拟机。对此记录下。 Java语言内置多线程支持： 一个java程序实际上是一个JVM进程。 JVM用一个主线程来执行main()方法。 在main()方法中又可以启动多个进程。 Java多线程创建MyThread类逻辑： 1.从Thread派生； 2.覆写run...
java-多线程 test
06-11
java-多线程 test
Java-多线程连接池模型
07-22
多线程连接池模型
14.java-多线程.md
08-18
14.java-多线程
java - juc - 多线程 - 学习 -思维导图
12-16
java - juc - 多线程 - 学习 -思维导图
使用Spring Boot和Spring Security构建安全的RESTful API
intwei的博客
05-17 658
本文详细介绍了如何使用Spring Boot和Spring Security构建安全的RESTful API，并结合JWT实现身份验证与授权。通过实际代码示例，帮助开发者快速上手。完整的项目代码可以在GitHub上找到。
上集：一个前端的血泪复仇记 —— 静态部署的胜利
最新发布
十步杀一人-千里不留行
05-17 1179
在《上集：一个前端的血泪复仇记 —— 静态部署的胜利》中，作者分享了在部署一个前后端分离的小项目时遇到的挑战和解决方案。项目后端使用Spring Boot，前端使用Next.js。在部署过程中，前端静态资源的处理成为主要难题。作者通过将Next.js生成的静态文件直接放入Spring Boot的static目录，简化了部署流程。然而，Spring Security的默认配置阻止了对这些静态资源的访问，导致403错误。通过调整SecurityConfig和WebConfig，作者成功解决了这一问题。此外，前端
WEB安全--Java安全--CC1利用链
m0_74800552的博客
05-14 1486
CC1利用链的原理与构建方式
HashSet
weixin_51718998的博客
05-15 829
（1）HashSet的去重机制：hashCode()+equals()，底层先通过存入对象，进行运算得到一个hash值，通过hash值得到对应的索引，如果发现table索引所在的位置，没有数据，就直接存放，如果有数据，就进行equals[遍历]比较，如果比较后，不相同就加入，否则就不加入。在开发中，选择什么集合实现类，主要取决于业务操作特点，然后根据集合实现类特性进行选择，分析如下：1）先判断存储的类型（一组对象[单列]或一组键值对[双列]）map.put("no1","hahaha");
Java多线程进度条实现技巧
### 知识点：Java多线程进度条的实现与应用 在现代软件开发中，多线程技术是提升应用程序性能和响应能力的关键技术之一。而进度条作为一种界面元素，可以向用户直观展示长时间运行任务的完成情况，提高用户体验。当...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值