2020-08-06

最新推荐文章于 2024-03-26 09:46:46 发布
最新推荐文章于 2024-03-26 09:46:46 发布
阅读量119 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43492559/article/details/107842808
版权

文章目录
一 进程和多线程简介
1.1 进程和线程
1.2 何为进程？
1.3 何为线程？
1.4 何为多线程？
1.5 为什么多线程是必要的？
1.6 为什么提倡多线程而不是多进程？
二 几个重要的概念
2.1 同步和异步
2.2 并发(Concurrency)和并行(Parallelism)
2.3 高并发
2.4 临界区
2.5 阻塞和非阻塞
三 使用多线程常见的三种方式
①继承Thread类
②实现Runnable接口
③使用线程池
四 实例变量和线程安全
4.1 不共享数据的情况
4.2 共享数据的情况
五 一些常用方法
5.1 currentThread()
5.2 getId()
5.3 getName()
5.4 getPriority()
5.5 isAlive()
5.6 sleep(long millis)
5.7 interrupt()
5.8 interrupted() 和isInterrupted()
5.9 setName(String name)
5.10 isDaemon()
5.11 setDaemon(boolean on)
5.12 join()
5.13 yield()
5.14 setPriority(int newPriority)
六 如何停止一个线程呢？
6.1 使用interrupt()方法
6.2 使用return停止线程
七 线程的优先级
八 Java多线程分类
8.1 多线程分类
8.2 如何设置守护线程？
Java 并发的基础知识，可能会在笔试中遇到，技术面试中也可能以并发知识环节提问的第一个问题出现。比如面试官可能会问你：“谈谈自己对于进程和线程的理解，两者的区别是什么？”

一 进程和多线程简介
1.1 进程和线程
进程和线程的对比这一知识点由于过于基础，所以在面试中很少碰到，但是极有可能会在笔试题中碰到。常见的提问形式是这样的：“什么是线程和进程?，请简要描述线程与进程的关系、区别及优缺点？ ”。

1.2 何为进程？
进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。如下图所示，在 windows 中通过查看任务管理器的方式，我们就可以清楚看到 window 当前运行的进程（.exe文件的运行）。

进程

1.3 何为线程？
线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。

1.4 何为多线程？
多线程就是多个线程同时运行或交替运行。单核CPU的话是顺序执行，也就是交替运行。多核CPU的话，因为每个CPU有自己的运算器，所以在多个CPU中可以同时运行。

1.5 为什么多线程是必要的？
个人觉得可以用一句话概括：开发高并发系统的基础，利用好多线程机制可以大大提高系统整体的并发能力以及性能。

1.6 为什么提倡多线程而不是多进程？
线程就是轻量级进程，是程序执行的最小单位。使用多线程而不是用多进程去进行并发程序的设计，是因为线程间的切换和调度的成本远远小于进程。

二 几个重要的概念
2.1 同步和异步
同步和异步通常用来形容一次方法调用。同步方法调用一旦开始，调用者必须等到方法调用返回后，才能继续后续的行为。异步方法调用更像一个消息传递，一旦开始，方法调用就会立即返回，调用者可以继续后续的操作。

关于异步目前比较经典以及常用的实现方式就是消息队列：在不使用消息队列服务器的时候，用户的请求数据直接写入数据库，在高并发的情况下数据库压力剧增，使得响应速度变慢。但是在使用消息队列之后，用户的请求数据发送给消息队列之后立即 返回，再由消息队列的消费者进程从消息队列中获取数据，异步写入数据库。由于消息队列服务器处理速度快于数据库（消息队列也比数据库有更好的伸缩性），因此响应速度得到大幅改善。

2.2 并发(Concurrency)和并行(Parallelism)
并发和并行是两个非常容易被混淆的概念。它们都可以表示两个或者多个任务一起执行，但是偏重点有些不同。并发偏重于多个任务交替执行，而多个任务之间有可能还是串行的。而并行是真正意义上的“同时执行”。

多线程在单核CPU的话是顺序执行，也就是交替运行（并发）。多核CPU的话，因为每个CPU有自己的运算器，所以在多个CPU中可以同时运行（并行）。

2.3 高并发
高并发（High Concurrency）是互联网分布式系统架构设计中必须考虑的因素之一，它通常是指，通过设计保证系统能够同时并行处理很多请求。

高并发相关常用的一些指标有响应时间（Response Time），吞吐量（Throughput），每秒查询率QPS（Query Per Second），并发用户数等。

2.4 临界区
临界区用来表示一种公共资源或者说是共享数据，可以被多个线程使用。但是每一次，只能有一个线程使用它，一旦临界区资源被占用，其他线程要想使用这个资源，就必须等待。在并行程序中，临界区资源是保护的对象。

2.5 阻塞和非阻塞
非阻塞指在不能立刻得到结果之前，该函数不会阻塞当前线程，而会立刻返回，而阻塞与之相反。

三 使用多线程常见的三种方式
前两种实际上很少使用，一般都是用线程池的方式比较多一点。

①继承Thread类
public class MyThread extends Thread {
@Override
public void run() {
super.run();
System.out.println(“MyThread”);
}
}
1
2
3
4
5
6
7
Run.java

public class Run {

public static void main(String[] args) {
	MyThread mythread = new MyThread();
	mythread.start();
	System.out.println("运行结束");
}

}

1
2
3
4
5
6
7
8
9
10
运行结果：

运行结束
MyThread
1
2
从上面的运行结果可以看出：线程是一个子任务，CPU以不确定的方式，或者说是以随机的时间来调用线程中的run方法。

②实现Runnable接口
推荐实现Runnable接口方式开发多线程，因为Java单继承但是可以实现多个接口。

MyRunnable.java

public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println(“MyRunnable”);
}
}
1
2
3
4
5
6
Run.java

public class Run {

public static void main(String[] args) {
	Runnable runnable=new MyRunnable();
	Thread thread=new Thread(runnable);
	thread.start();
	System.out.println("运行结束！");
}

}
1
2
3
4
5
6
7
8
9
10
运行结果：

运行结束
MyThread
1
2
③使用线程池
使用线程池的方式也是最推荐的一种方式，另外，《阿里巴巴Java开发手册》在第一章第六节并发处理这一部分也强调到“线程资源必须通过线程池提供，不允许在应用中自行显示创建线程”。这里就不给大家演示代码了，线程池这一节会详细介绍到这部分内容。

四 实例变量和线程安全
线程类中的实例变量针对其他线程可以有共享和不共享之分。下面通过两个简单的例子来说明！

4.1 不共享数据的情况

/**
*

  • @author SnailClimb

  • @date 2018年10月30日

  • @Description: 多个线程之间不共享变量线程安全的情况
    */
    public class MyThread extends Thread {

    private int count = 5;

    public MyThread(String name) {
    super();
    this.setName(name);
    }

    @Override
    public void run() {
    super.run();
    while (count > 0) {
    count–;
    System.out.println(“由 " + MyThread.currentThread().getName() + " 计算，count=” + count);
    }
    }

    public static void main(String[] args) {
    MyThread a = new MyThread(“A”);
    MyThread b = new MyThread(“B”);
    MyThread c = new MyThread(“C”);
    a.start();
    b.start();
    c.start();
    }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    运行结果：
    在这里插入图片描述
    可以看出每个线程都有一个属于自己的实例变量count，它们之间互不影响。我们再来看看另一种情况。

4.2 共享数据的情况
/**
*

  • @author SnailClimb

  • @date 2018年10月30日

  • @Description: 多个线程之间共享变量线程不安全的情况
    */
    public class SharedVariableThread extends Thread {
    private int count = 5;

    @Override
    public void run() {
    super.run();
    count–;
    System.out.println(“由 " + SharedVariableThread.currentThread().getName() + " 计算，count=” + count);
    }

    public static void main(String[] args) {

     SharedVariableThread mythread = new SharedVariableThread();
 // 下列线程都是通过mythread对象创建的
 Thread a = new Thread(mythread, "A");
 Thread b = new Thread(mythread, "B");
 Thread c = new Thread(mythread, "C");
 Thread d = new Thread(mythread, "D");
 Thread e = new Thread(mythread, "E");
 a.start();
 b.start();
 c.start();
 d.start();
 e.start();

    }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    运行结果：

在这里插入图片描述

可以看出这里已经出现了错误，我们想要的是依次递减的结果。为什么呢？？

因为在大多数jvm中，count–的操作分为如下下三步：

取得原有count值
计算i -1
对i进行赋值
所以多个线程同时访问时出现问题就是难以避免的了。

那么有没有什么解决办法呢？

答案是：当然有，而且很简单。给大家提供两种解决办法：一种是利用 synchronized 关键字（保证任意时刻只能有一个线程执行该方法），一种是利用 AtomicInteger 类（JUC 中的 Atomic 原子类）。大家如果之前没有接触 Java 多线程的话，可能对这两个概念不太熟悉，不过不要担心我后面会一一向你介绍到！这里不能用 volatile 关键字，因为 volatile 关键字不能保证复合操作的原子性。

五 一些常用方法
5.1 currentThread()
返回对当前正在执行的线程对象的引用。

5.2 getId()
返回此线程的标识符

5.3 getName()
返回此线程的名称

5.4 getPriority()
返回此线程的优先级

5.5 isAlive()
测试这个线程是否还处于活动状态。

什么是活动状态呢？

活动状态就是线程已经启动且尚未终止。线程处于正在运行或准备运行的状态。

5.6 sleep(long millis)
使当前正在执行的线程以指定的毫秒数“休眠”（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性。

5.7 interrupt()
中断这个线程。

5.8 interrupted() 和isInterrupted()
interrupted()：测试当前线程是否已经是中断状态，执行后具有将状态标志清除为false的功能

isInterrupted()： 测试线程Thread对相关是否已经是中断状态，但部清楚状态标志

5.9 setName(String name)
将此线程的名称更改为等于参数 name 。

5.10 isDaemon()
测试这个线程是否是守护线程。

5.11 setDaemon(boolean on)
将此线程标记为 daemon线程或用户线程。

5.12 join()
在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是 主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。

join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行

5.13 yield()
yield()方法的作用是放弃当前的CPU资源，将它让给其他的任务去占用CPU时间。注意：放弃的时间不确定，可能一会就会重新获得CPU时间片。

5.14 setPriority(int newPriority)
更改此线程的优先级

六 如何停止一个线程呢？
stop(),suspend(),resume()（仅用于与suspend()一起使用）这些方法已被弃用，所以我这里不予讲解。

在这里插入图片描述

6.1 使用interrupt()方法
我们上面提到了interrupt()方法，先来试一下interrupt()方法能不能停止线程

public class MyThread extends Thread {
@Override
public void run() {
super.run();
for (int i = 0; i < 5000000; i++) {
System.out.println(“i=” + (i + 1));
}
}
public static void main(String[] args) {
try {
MyThread thread = new MyThread();
thread.start();
Thread.sleep(2000);
thread.interrupt();
} catch (InterruptedException e) {
System.out.println(“main catch”);
e.printStackTrace();
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
运行上诉代码你会发现，线程并不会终止。

针对上面代码的一个改进：

interrupted()方法判断线程是否停止，如果是停止状态则break

/**
*

  • @author SnailClimb

  • @date 2018年10月30日

  • @Description: 使用interrupt()方法终止线程
    */
    public class InterruptThread2 extends Thread {
    @Override
    public void run() {
    super.run();
    for (int i = 0; i < 500000; i++) {
    if (this.interrupted()) {
    System.out.println(“已经是停止状态了!我要退出了!”);
    break;
    }
    System.out.println(“i=” + (i + 1));
    }
    System.out.println(“看到这句话说明线程并未终止------”);
    }

    public static void main(String[] args) {
    try {
    InterruptThread2 thread = new InterruptThread2();
    thread.start();
    Thread.sleep(2000);
    thread.interrupt();
    } catch (InterruptedException e) {
    System.out.println(“main catch”);
    e.printStackTrace();
    }
    }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    运行结果：
    运行结果
    for循环虽然停止执行了，但是for循环下面的语句还是会执行，说明线程并未被停止。

6.2 使用return停止线程
public class MyThread extends Thread {

@Override
public void run() {
		while (true) {
			if (this.isInterrupted()) {
				System.out.println("ֹͣ停止了!");
				return;
			}
			System.out.println("timer=" + System.currentTimeMillis());
		}
}
public static void main(String[] args) throws InterruptedException {
	MyThread t=new MyThread();
	t.start();
	Thread.sleep(2000);
	t.interrupt();
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
运行结果：

在这里插入图片描述

当然还有其他停止线程的方法，后面再做介绍。

七 线程的优先级
每个线程都具有各自的优先级，线程的优先级可以在程序中表明该线程的重要性，如果有很多线程处于就绪状态，系统会根据优先级来决定首先使哪个线程进入运行状态。但这个并不意味着低
优先级的线程得不到运行，而只是它运行的几率比较小，如垃圾回收机制线程的优先级就比较低。所以很多垃圾得不到及时的回收处理。

线程优先级具有继承特性比如A线程启动B线程，则B线程的优先级和A是一样的。

线程优先级具有随机性也就是说线程优先级高的不一定每一次都先执行完。

Thread类中包含的成员变量代表了线程的某些优先级。如Thread.MIN_PRIORITY（常数1），Thread.NORM_PRIORITY（常数5）,
Thread.MAX_PRIORITY（常数10）。其中每个线程的优先级都在Thread.MIN_PRIORITY（常数1） 到Thread.MAX_PRIORITY（常数10） 之间，在默认情况下优先级都是Thread.NORM_PRIORITY（常数5）。

学过操作系统这门课程的话，我们可以发现多线程优先级或多或少借鉴了操作系统对进程的管理。

线程优先级具有继承特性测试代码：

MyThread1.java：

public class MyThread1 extends Thread {
@Override
public void run() {
System.out.println(“MyThread1 run priority=” + this.getPriority());
MyThread2 thread2 = new MyThread2();
thread2.start();
}
}

1
2
3
4
5
6
7
8
9
MyThread2.java：

public class MyThread2 extends Thread {
@Override
public void run() {
System.out.println(“MyThread2 run priority=” + this.getPriority());
}
}
1
2
3
4
5
6
Run.java：

public class Run {
public static void main(String[] args) {
System.out.println(“main thread begin priority=”
+ Thread.currentThread().getPriority());
Thread.currentThread().setPriority(6);
System.out.println(“main thread end priority=”
+ Thread.currentThread().getPriority());
MyThread1 thread1 = new MyThread1();
thread1.start();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
运行结果：
运行结果

八 Java多线程分类
8.1 多线程分类
用户线程：运行在前台，执行具体的任务，如程序的主线程、连接网络的子线程等都是用户线程

守护线程：运行在后台，为其他前台线程服务.也可以说守护线程是JVM中非守护线程的 “佣人”。

特点：一旦所有用户线程都结束运行，守护线程会随JVM一起结束工作

应用：数据库连接池中的检测线程，JVM虚拟机启动后的检测线程

最常见的守护线程：垃圾回收线程

8.2 如何设置守护线程？
可以通过调用Thead类的setDaemon(true)方法设置当前的线程为守护线程

注意事项：

  1. setDaemon(true)必须在start（）方法前执行，否则会抛出IllegalThreadStateException异常
  2. 在守护线程中产生的新线程也是守护线程
  3. 不是所有的任务都可以分配给守护线程来执行，比如读写操作或者计算逻辑
    1
    2
    3
    MyThread.java：

public class MyThread extends Thread {
private int i = 0;

@Override
public void run() {
	try {
		while (true) {
			i++;
			System.out.println("i=" + (i));
			Thread.sleep(100);
		}
	} catch (InterruptedException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Run.java：

public class Run {
public static void main(String[] args) {
try {
MyThread thread = new MyThread();
thread.setDaemon(true);
thread.start();
Thread.sleep(5000);
System.out.println(“我离开thread对象也不再打印了，也就是停止了！”);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
运行结果：
守护线程

€兴
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
常见的几种多线程架构
Sandy_WYM_的博客
03-24 2320
在应用程序中使用多线程处理需精选出具有内在并发性与并行性的架构，有些应用程序天生就适合使用多线程处理的常见架构，三种常见的多线程处理架构：（１）客户机/服务器（２）事件驱动编程（３）黑板。 客户机/服务器 客户机/服务器将工作模式分为两个端口，一端（客户机）请求数据或者动作，另一端（服务器）完成该请求。例如，使用一个命名管道连接两个进程时，创建管道的进程通常称为服务器，请求此管道的进程通常称为...
muyouyang#leetcode-python#2020-08-06-每日一题1
07-25
更多python分类刷题题解代码：请参考github, 知乎336. 回文对暴力法： 直接遍历时间复杂度为：m × n^2if not word: return
多线程框架通用多线程源码.zip
06-05
易语言版的多线程通用框架，示范了多线程启动、暂停、恢复、销毁的详细过程，有助于对多线程的理解，运用。
三种多线程使用框架
qq_42719291的博客
12-05 1138
三种多线程使用框架 1 Thread类使用框架 public class MyThread extends Thread{ public void run() {} } public static void main(String[] args) { Thread threadA = new MyThread(); Thread threadB = new MyThread(); threadA.start(); threadB.start(); //或new Thread
多线程篇1——多线程框架
技术尖刀的博客
02-28 1130
计算机的很多知识是相通的，比如多线程与多进程，在Linux中查看进程和线程的方式更为直观，比如使用top命令与ps命令 那么进程与线程究竟该怎么理解呢？ 设想一下，我需要打开我的笔记本，那么按下按钮的时候，就开启了“开机”这个进程号为1的进程 在开机的过程中，电源模块线程与CPU运算调度线程以及其他的好多线程一起完成了这个任务 总之，进程是“粗壮”的，线程是“多的” 一，多线程相关介绍 进程和线程是包含关系，但是多任务既可以由多进程实现，也可以由单进程内的多线程实现，还可以混合多进程＋多线程。 和多线程.
JAVA基础-多线程入门（详解）
0
07-28 854
线程（Thread)是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。一个线程指的是进程中一个单一顺序的控制流，一个进程可以并发多个线程，每个线程并行执行不同的任务。线程在Unix SystemV及SunOS中也被称为轻量进程（Lightweight Processes),但“轻量进程”更多指内核线程（Kernel Thread),而用户线程（User Thread)则被称为“线程”。
20200806-天风证券-天风证券2020年7月私募基金月报（2020-08-06）.pdf
09-03
20200806-天风证券-天风证券2020年7月私募基金月报（2020-08-06）
Draft 2020-08-01 06:06:10-数据集
03-25
COAD_GSE81861
EMMC04G-M627-A01-EMMC5.13.3V_2020-06-08.PDF
08-02
EMMC04G-M627-A01-EMMC5.13.3V_2020-06-08.PDF
Draft 2020-04-06 08:57:08-数据集
03-26
Datawhale-零基础入门数据挖掘—二手车预测交易价格（回归问题）
Java数据结构之优先级队列（堆）
fear_wolf的博客
11-05 1358
Java集合框架中提供了和两种类型的优先级队列，PriorityQueue是线程不安全的，PriorityBlockingQueue是线程安全的，本文主要介绍PriorityQueue使用时必须导入Priority所在的包，即：PriorityQueue中放置的元素必须能够比较大小，不能插入无法比较大小的对象，否则会抛出ClassCastException异常不能插入null对象，否则会抛出ClassCastException异常没有容量限制，可以插入任意多个元素，其内部可以自动扩容。
Java多线程_并发集合框架
weixin_49076273的博客
01-14 536
Iterator接口是集合框架的父接口，Collection接口继承了Iterator接口；而接口List、Set、Queue继承了Collection接口；而Deque接口继承了Queue接口。使用接口继承接口可以让继承的接口对被继承的接口进行扩展。List接口的实现类中的元素是有序可重复的，而Set接口的实现类中的元素是无序不可重复的。接口Queue支持对表头的操作，而Deque对Queue进行扩展，也支持对表尾进行操作。java.util.Concurrent包下的类都是线程安全的。
探秘高效能计算库——CMC：一个轻量级、高性能的多线程任务调度框架
最新发布
gitblog_00051的博客
03-26 808
探秘高效能计算库——CMC：一个轻量级、高性能的多线程任务调度框架 项目地址:https://gitcode.com/HobbitLong/CMC 在计算机科学中，高效的并行计算和多线程任务调度是提升程序性能的关键。今天我们要介绍的就是这样一款开源工具——CMC（ Concurrent Multi-Tasking），它是一个轻量级且高度可定制的多线程任务调度框架。 项目简介 CMC由开发者Hob...
多线程设计架构模式
u014549867的博客
03-05 475
观察者模式监控任务的生命周期 利用观察者模式的思想，定义特殊的线程类，final 修饰重写run 方法，在其中各个时刻加入通知方法的调用。 Sing Thread Execution 设计模式 同一时刻只能有一个线程访问共享资源。通过对共享资源加锁实现。 ...
【2023】多线程之 Fork/Join框架
weixin_52315708的博客
07-17 283
Fork/Join框架是一个实现了ExecutorService接口的多线程处理器，它专为那些可以通过递归分解成更细小的任务而设计，最大化的利用多核处理器来提高应用程序的性能。与其他ExecutorService相关的实现相同的是，Fork/Join框架会将任务分配给线程池中的线程。而与之不同的是，Fork/Join框架在执行任务时使用了工作窃取算法。fork在英文里有分叉的意思，join在英文里连接、结合的意思。
Java基础--多线程详解
a18792721831的博客
06-06 2157
1.线程的概念； 2.线程如何使用； 3.jdk支持的基本线程池； 4.线程生命周期； 5.线程启动与终止； 6.后台线程； 7.线程继承其他类；
java多线程入门（很到位）
weixin_45131680的博客
01-13 260
java中之所以有多线程机制，目的就是为了提高程序的处理效率。 对于单核的CPU来说，不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉。对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于CPU的处理速度极快，多个线程之间频繁切换执行，跟人来的感觉是多个事情同时在做。
Java多线程知识点，看这一篇就够了！（超详细）
weixin_73616913的博客
08-13 2089
1、饿汉模式（迫切）程序启动，类加载之后，立即创建出实例2、懒汉模式（延时）在第一次使用实例的时候，再创建，否则能不创建就不创建举个例子：编译器打开一个文件，假设有一个超大的文件，
《多线程系列五》一文读懂Java多线程框架原理
我是香菜
04-21 2316
目录 1、AQS 是什么？ 2、AQS 模型 3、AQS state 4、AQS 两种资源共享方式： 5、模板方式实现自定义 6、锁的分类:公平锁和非公平锁，乐观锁和悲观锁 7、CAS 8、总结 1、AQS 是什么？ AQS 是类 AbstractQueuedSynchronizer的简称，也是常用锁的基类，比如常见的ReentrantLock，Semaphore，CountDownLatch 等等。 AQS提供了一种实现阻塞锁和一系列依赖FIFO等待队列的同步器的框架。是Java..
将 Date 类型2020-06-08 00:00:00 的结果截取为 2020-06-08 类型依旧是Date
06-09
将 Date 类型的时间戳 "2020-06-08 00:00:00" 转换为 "2020-06-08" 的字符串格式，可以使用 SimpleDateFormat 对象来实现。示例代码如下： ```java // 原始的时间戳 Date date = new Date("2020-06-08 00:00:00"); ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值