JavaSE
多线程
并发与并行
- 并行：指两个或多个事件在同一时刻发生（同时执行）。
- 并发：指两个或多个事件在同一个时间段内发生(交替执行)。
在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。而在多个 CPU 系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU），实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU，便是多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。
注意：单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理,线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。
线程与进程
- 进程：进程是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程。
- 线程：是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
进程
线程
进程与线程的区别
- 进程：有独立的内存空间，进程中的数据存放空间（堆空间和栈空间）是独立的，至少有一个线程。
- 线程：堆空间是共享的，栈空间是独立的，线程消耗的资源比进程小的多。
**注意：**下面内容为了解知识点
1.因为一个进程中的多个线程是并发运行的，那么从微观角度看也是有先后顺序的，哪个线程执行完全取决于 CPU 的调度，是干涉不了的。而这也就造成的多线程的随机性。
2.Java 程序的进程里面至少包含两个线程，主进程也就是 main()方法线程，另外一个是垃圾回收机制线程。每当使用 java 命令执行一个类时，实际上都会启动一个 JVM，每一个 JVM 实际上就是在操作系统中启动了一个线程，java 本身具备了垃圾的收集机制，所以在 Java 运行时至少会启动两个线程。
3.由于创建一个线程的开销比创建一个进程的开销小的多，那么在开发多任务运行的时候，通常考虑创建多线程，而不是创建多进程。
线程调度
- 分时调度
所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。 - 抢占式调度
优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
Thread类
Thread类的构造方法
线程开启需要用到了java.lang.Thread类，API中该类中定义了有关线程的一些方法，具体如下：
public Thread():分配一个新的线程对象。public Thread(String name):分配一个指定名字的新的线程对象。public Thread(Runnable target):分配一个带有指定目标新的线程对象。public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。
Thread类的常用方法
public String getName():获取当前线程名称。public void start():导致此线程开始执行; Java虚拟机调用此线程的run方法。public void run():此线程要执行的任务在此处定义代码。public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。public static Thread currentThread():返回对当前正在执行的线程对象的引用。
创建线程方式一—继承方式
Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。Java中通过继承Thread类来创建并启动多线程的步骤如下：
- 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务，因此把run()方法称为线程执行体。
- 创建Thread子类的实例，即创建了线程对象。
- 调用线程对象的start()方法来启动该线程。
代码如下：
测试类：
public class Demo {
public static void main(String[] args) {
//创建自定义线程对象
MyThread mt = new MyThread("新的线程！");
//开启新线程
mt.start();
//在主方法中执行for循环
for (int i = 0; i < 200; i++) {
System.out.println("main线程！"+i);
}
}
}
自定义线程类：
public class MyThread extends Thread {
//定义指定线程名称的构造方法
public MyThread(String name) {
//调用父类的String参数的构造方法，指定线程的名称
super(name);
}
public MyThread() {
//不指定线程的名字,线程有默认的名字Thread-0
}
/**
* 重写run方法，完成该线程执行的逻辑
*/
@Override
public void run() {
for (int i = 0; i < 200; i++) {
System.out.println(getName()+"：正在执行！"+i);
}
}
}
创建线程的方式二—实现方式
采用java.lang.Runnable也是非常常见的一种，只需要重写run方法即可。
步骤如下：
- 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
- 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
- 调用线程对象的start()方法来启动线程。
代码如下：
public class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()+" "+i);
}
}
}
public class Demo {
public static void main(String[] args) {
//创建自定义类对象 线程任务对象
MyRunnable mr = new MyRunnable();
//创建线程对象
Thread t = new Thread(mr, "工作");
t.start();
for (int i = 0; i < 20; i++) {
System.out.println("学习 " + i);
}
}
}
通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。
在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。
实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。
tips：Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。
Thread和Runnable的区别
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
总结：
实现Runnable接口比继承Thread类所具有的优势：
- 适合多个相同的程序代码的线程去共享同一个资源。
- 可以避免java中的单继承的局限性。
- 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
- 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
匿名内部类方式
使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。
使用匿名内部类的方式实现Runnable接口，重写Runnable接口中的run方法：
public class NoNameInnerClassThread {
public static void main(String[] args) {
// new Runnable(){
// public void run(){
// for (int i = 0; i < 20; i++) {
// System.out.println("小明:"+i);
// }
// }
// }; //---这个整体 相当于new MyRunnable()
Runnable r = new Runnable(){
public void run(){
for (int i = 0; i < 20; i++) {
System.out.println("小明:"+i);
}
}
};
new Thread(r).start();
for (int i = 0; i < 20; i++) {
System.out.println("小红:"+i);
}
}
}
高并发及线程安全
高并发及线程安全的概述
- 高并发：是指在某个时间点上，有大量的用户(线程)同时访问同一资源。例如：天猫的双11购物节、12306的在线购票在某个时间点上，都会面临大量用户同时抢购同一件商品/车票的情况。
- 线程安全：在某个时间点上，当大量用户(线程)访问同一资源时，由于多线程运行机制的原因，可能会导致被访问的资源出现"数据污染"的问题。
多线程的运行机制
-
当一个线程启动后，JVM会为其分配一个独立的"线程栈区"，这个线程会在这个独立的栈区中运行。
-
看一下简单的线程的代码：
- 一个线程类：
public class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("小明: " + i);
}
}
}
- 测试类：
public class Demo {
public static void main(String[] args) {
//1.创建线程对象
MyThread mt = new MyThread();
//2.启动线程
mt.start();
for (int i = 0; i < 20; i++) {
System.out.println("小红: " + i);
}
}
}
- 启动后，内存的运行机制：
- 多个线程在各自栈区中独立、无序的运行，当访问一些代码，或者同一个变量时，就可能会产生一些问题
多线程的安全性问题-可见性
例如下面的程序，先启动一个线程，在线程中将一个变量的值更改，而主线程却一直无法获得此变量的新值。
- 线程类：
public class MyThread extends Thread {
boolean flag = false;// 主和子线程共享变量
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 把flag的值改为true
flag = true;
System.out.println("修改后flag的值为:"+flag);
}
}
- 测试类：
public class Test {
public static void main(String[] args) {
/*
多线程的安全性问题-可见性:
一个线程没有看见另一个线程对共享变量的修改
*/
// 创建子线程并启动
MyThread mt = new MyThread();
mt.start();
// 主线程
while (true){
if (MyThread.flag == true){
System.out.println("死循环结束");
break;
}
}
/*
按照分析结果应该是: 子线程把共享变量flag改为true,然后主线程的死循环就可以结束
实际结果是: 子线程把共享变量flag改为true,但主线程依然是死循环
为什么?
其实原因就是子线程对共享变量flag修改后的值,对于主线程是不可见的
*/
}
}
public class MyThread extends Thread{
static boolean flag = false;// 主线程和子线程共享的变量
@Override
public void run() {
try {
Thread.sleep(3000);// 暂停\醒了
} catch (InterruptedException e) {
e.printStackTrace();
}
flag = true;
System.out.println("flag修改后的值为:"+flag);
}
}
多线程的安全性问题-有序性
-
有些时候“编译器”在编译代码时，会对代码进行“重排”，例如：
int a = 10; //1
int b = 20; //2
int c = a + b; //3第一行和第二行可能会被“重排”：可能先编译第二行，再编译第一行，总之在执行第三行之前，会将1,2编译完毕。1和2先编译谁，不影响第三行的结果。
-
但在“多线程”情况下，代码重排，可能会对另一个线程访问的结果产生影响：
多线程环境下，我们通常不希望对一些代码进行重排的！！
多线程的安全性问题-原子性
以下示例：
- 制作线程类
public class MyThread extends Thread {
public static int a = 0;
@Override
public void run() {
for (int i = 0; i < 100000; i++) {
a++;
}
System.out.println("修改完毕！");
}
}
- 制作测试类
public class Demo {
public static void main(String[] args) {
/*
概述：所谓的原子性是指在一次操作或者多次操作中，
要么所有的操作全部都得到了执行并且不会受到任何因素的干扰而中断，
要么所有的操作都不执行，多个操作是一个不可以分割的整体。
演示高并发原子性问题:
例如: 一条子线程和一条主线程都对共享变量a进行++操作,每条线程对a++操作100000次
最终期望a的值为:200000
出现高并发原子性问题的原因:虽然计算了2次，但是只对a进行了1次修改
*/
// 创建并启动子线程
MyThread mt = new MyThread();
mt.start();
// a变量自增3万次
for (int i = 0; i < 100000; i++) {
mt.a++;
}
// 暂定3秒,为了保证子线程执行完毕
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("最终a的值为:"+mt.a);// 期望:200000
}
}
原因：两个线程访问同一个变量a的代码不具有"原子性"
volatile关键字
什么是volatile关键字
- volatile是一个"变量修饰符"，它只能修饰"成员变量"，它能强制线程每次从主内存获取值，并能保证此变量不会被编译器优化。
- volatile能解决变量的可见性、有序性。
- volatile不能解决变量的原子性。
volatile解决可见性
将线程类MyThread做如下修改：
- 线程类
public class MyThread extends Thread {
public static volatile int a = 0;//增加volatile关键字
@Override
public void run() {
System.out.println("线程启动，休息2秒...");
try {
Thread.sleep(1000 * 2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("将a的值改为1");
a = 1;
System.out.println("线程结束...");
}
}
- 测试类
public class Demo {
public static void main(String[] args) {
//1.启动线程
MyThread t = new MyThread();
t.start();
//2.主线程继续
while (true) {
if (MyThread.a == 1) {
System.out.println("主线程读到了a = 1");
}
}
}
}
当变量被修饰为volatile时，会迫使线程每次使用此变量，都会去主内存获取，保证其可见性
volatile解决有序性
当变量被修饰为volatile时，会禁止代码重排
volatile不能解决原子性
加入volatile关键字并不能解决原子性：
- 线程类：
public class MyThread extends Thread {
public static volatile int a = 0;
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
//线程1：取出a的值a=0(被暂停)
a++;
//写回
}
System.out.println("修改完毕！");
}
}
- 测试类：
public class Demo {
public static void main(String[] args) throws InterruptedException {
//1.启动两个线程
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
t1.start();
t2.start();
Thread.sleep(1000);
System.out.println("获取a最终值：" + MyThread.a);//最终结果仍然不正确。
}
}
所以，volatile关键字只能解决"变量"的可见性、有序性问题，并不能解决原子性问题
原子类
原子类概述
在java.util.concurrent.atomic包下定义了一些对“变量”操作的“原子类”:
1).java.util.concurrent.atomic.AtomicInteger：对int变量操作的“原子类”;
2).java.util.concurrent.atomic.AtomicLong：对long变量操作的“原子类”;
3).java.util.concurrent.atomic.AtomicBoolean：对boolean变量操作的“原子类”;
它们可以保证对“变量”操作的：原子性、有序性、可见性。
AtomicInteger类示例
可以通过AtomicInteger类，来看看它们是怎样工作的
- 线程类：
public class MyThread extends Thread {
//public static volatile int a = 0;//不直接使用基本类型变量
//改用"原子类"
public static AtomicInteger a = new AtomicInteger(0);
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
// a++;
a.getAndIncrement();//先获取，再自增1：a++
}
System.out.println("修改完毕！");
}
}
- 测试类：
public class Demo {
public static void main(String[] args) throws InterruptedException {
//1.启动两个线程
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
t1.start();
t2.start();
Thread.sleep(1000);
System.out.println("获取a最终值：" + MyThread.a.get());
}
}
我们能看到，无论程序运行多少次，其结果总是正确的！
AtomicInteger类的工作原理-CAS机制
AtomicIntegerArray类示例
-
常用的数组操作的原子类：
1).java.util.concurrent.atomic.AtomicIntegetArray:对int数组操作的原子类。 int[ ] 2).java.util.concurrent.atomic.AtomicLongArray：对long数组操作的原子类。long[ ]
3).java.util.concurrent.atomic.AtomicReferenceArray：对引用类型数组操作的原子类。Object[ ]
-
数组的多线程并发访问的安全性问题：
- 线程类：
public class MyThread extends Thread { private static int[] intArray = new int[1000];//不直接使用数组 @Override public void run() { for (int i = 0; i < arr.length(); i++) { intArray[i]++; } } }- 测试类：
public class Demo { public static void main(String[] args) throws InterruptedException { for (int i = 0; i < 1000; i++) { new MyThread().start();//创建1000个线程，每个线程为数组的每个元素+1 } Thread.sleep(1000 * 5);//让所有线程执行完毕 System.out.println("主线程休息5秒醒来"); for (int i = 0; i < MyThread.intArray.length(); i++) { System.out.println(MyThread.intArray[i]); } } }正常情况，数组的每个元素最终结果应为：1000，而实际打印：
1000 1000 1000 1000 999 999 999 999 999 999 999 999 1000 1000 1000 1000可以发现，有些元素并不是1000.
-
为保证数组的多线程安全，改用AtomicIntegerArray类，演示：
- 线程类：
public class MyThread extends Thread { private static int[] intArray = new int[1000];//定义一个数组 //改用原子类，使用数组构造 public static AtomicIntegerArray arr = new AtomicIntegerArray(intArray); @Override public void run() { for (int i = 0; i < arr.length(); i++) { arr.addAndGet(i, 1);//将i位置上的元素 + 1 } } }
- 测试类：
public class Demo {
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 1000; i++) {
new MyThread().start();
}
Thread.sleep(1000 * 5);//让所有线程执行完毕
System.out.println("主线程休息5秒醒来");
for (int i = 0; i < MyThread.arr.length(); i++) {
System.out.println(MyThread.arr.get(i));
}
}
}
现在能看到，每次运行的结果都是正确的。
synchronized关键字
多行代码的原子性问题
-
AtomicInteger类只能保证"变量"的原子性操作，而对多行代码进行"原子性"操作，使用AtomicInteger类就不能达到效果了。
-
通过一个案例，演示线程的安全问题：
电影院要卖票，模拟电影院的卖票过程。假设要播放的电影是 “奥特曼”，本次电影的座位共100个(本场电影只能卖100张票)。
模拟电影院的售票窗口，实现多个窗口同时卖 “奥特曼”这场电影票(多个窗口一起卖这100张票)需要窗口，采用线程对象来模拟；需要票，Runnable接口子类来模拟。
模拟票：
public class MyRunnable implements Runnable {
int tickets = 100;// 4个窗口共同卖的票 共享变量
@Override
public void run() {
// 实现卖票的操作
// 死循环卖票
while (true){
// 当票卖完了,就结束
if (tickets < 1){
break;
}
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":正在出售第"+tickets+"张票");
tickets--;
}
}
}
测试类：
public class Test {
public static void main(String[] args) {
/*
多行代码的原子性问题:
通过案例演示该问题: 电影院4个窗口卖票,卖的是同一份票,这份票总共有100张票
分析:
1. 电影院4个窗口 相当于 4条线程
2. 电影院4个窗口 卖票的操作是一样 相当于每条线程的任务是一样的
*/
// 电影院4个窗口 去卖票
MyRunnable mr = new MyRunnable();
Thread t1 = new Thread(mr,"窗口1");
Thread t2 = new Thread(mr,"窗口2");
Thread t3 = new Thread(mr,"窗口3");
Thread t4 = new Thread(mr,"窗口4");
t1.start();
t2.start();
t3.start();
t4.start();
}
}
程序执行后,结果会出现的问题
发现程序出现了两个问题：
- 相同的票数,比如100这张票被卖了四回。
- 不存在的票，比如0票与-1票,-2票，是不存在的。
这种问题，几个窗口(线程)票数不同步了，这种问题称为线程不安全。
卖票案例问题分析:
synchronized关键字概述
-
synchronized关键字：表示“同步”的。它可以对“多行代码”进行“同步”——将多行代码当成是一个完整的整体，一个线程如果进入到这个代码块中，会全部执行完毕，执行结束后，其它线程才会执行。这样可以保证这多行的代码作为完整的整体，被一个线程完整的执行完毕。
-
synchronized被称为“重量级的锁”方式，也是“悲观锁”——效率比较低。
-
synchronized有几种使用方式：
a).同步代码块
b).同步方法【常用】
当使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。
要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制(synchronized)来解决。
根据案例简述：
窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。
同步代码块
- 同步代码块：
synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
格式:
synchronized(同步锁){
需要同步操作的代码
}
同步锁:
对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁。
- 锁对象 可以是任意类型。
- 多个线程对象 要使用同一把锁。
注意：在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED)。
使用同步代码块解决代码：
public class MyRunnable implements Runnable {
int tickets = 100;// 4个窗口共同卖的票 共享变量
@Override
public void run() {
// 实现卖票的操作
// 死循环卖票
while (true) {
// 当票卖完了,就结束
// 加锁
synchronized (this) {// mr钥匙
if (tickets < 1) {
break;
}
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":正在出售第" + tickets + "张票");
tickets--;
}
// 释放锁
}
}
}
public class Test {
//static Object lock = new Object();
public static void main(String[] args) {
/*
解决多行代码的原子性问题:
同步代码块:
概述:synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
格式:
synchronized(锁对象){
}
锁对象:
1.锁对象可以是任意类的对象
2.多条线程想要实现同步,那么锁对象必须一致
*/
// 电影院4个窗口 去卖票
MyRunnable mr = new MyRunnable();
Thread t1 = new Thread(mr,"窗口1");
Thread t2 = new Thread(mr,"窗口2");
Thread t3 = new Thread(mr,"窗口3");
Thread t4 = new Thread(mr,"窗口4");
t1.start();
t2.start();
t3.start();
t4.start();
/*
发现程序出现了两个问题：
1. 相同的票数,比如100这张票被卖了四回。
2. 不存在的票，比如0票与-1票,-2票，是不存在的。
*/
}
}
当使用了同步代码块后，上述的线程的安全问题解决了。
同步方法
- 同步方法：使用synchronized修饰的方法，就叫做同步方法，保证A线程执行该方法的时候，其他线程只能在方法外等着。
格式：
public synchronized void method(){
可能会产生线程安全问题的代码
}
同步锁是谁?
对于非static方法,同步锁就是this。
对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。
使用同步方法代码如下：
public class MyRunnable implements Runnable {
int tickets = 100;// 4个窗口共同卖的票 共享变量
@Override
public void run() {
// 实现卖票的操作
// 死循环卖票
while (true) {
// 当票卖完了,就结束
// 加锁
if (sellTickets()) break;
// 释放锁
}
}
private synchronized boolean sellTickets() {
if (tickets < 1) {
return true;
}
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":正在出售第" + tickets + "张票");
tickets--;
return false;
}
}
public class Test {
//static Object lock = new Object();
public static void main(String[] args) {
/*
解决多行代码的原子性问题:
同步方法:
概述:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。
格式:
修饰符 synchronized 返回值类型 方法名(参数列表){}
锁对象:
1.非静态同步方法: 锁对象是this
2.静态同步方法: 锁对象是该方法所在类的字节码文件对象 类名.class
线程A中使用的是同步代码块,线程B中使用的是同步方法,线程A和线程B要实现同步,
那么线程A中的同步代码块锁对象和线程B中的同步方法的锁对象要一致,否则锁不住
*/
// 电影院4个窗口 去卖票
MyRunnable mr = new MyRunnable();
Thread t1 = new Thread(mr,"窗口1");
Thread t2 = new Thread(mr,"窗口2");
Thread t3 = new Thread(mr,"窗口3");
Thread t4 = new Thread(mr,"窗口4");
t1.start();
t2.start();
t3.start();
t4.start();
/*
发现程序出现了两个问题：
1. 相同的票数,比如100这张票被卖了四回。
2. 不存在的票，比如0票与-1票,-2票，是不存在的。
*/
}
}
Lock锁
java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有，除此之外更强大
Lock锁也称同步锁，加锁与释放锁方法化了，如下：
public void lock():加同步锁。public void unlock():释放同步锁。
使用如下：
public class MyRunnable implements Runnable {
int tickets = 100;// 4个窗口共同卖的票 共享变量
Lock lock = new ReentrantLock();
@Override
public void run() {
// 实现卖票的操作
// 死循环卖票
while (true) {
// 当票卖完了,就结束
// 加锁
lock.lock();
if (tickets < 1) {// 窗口1 0
lock.unlock();
break;// 结束卖票
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":正在出售第" + tickets + "张票");
tickets--;
// 释放锁
lock.unlock();
}
}
}
并发包
CopyOnWriteArrayList
-
ArrayList的线程不安全：
- 定义线程类：
public class MyThread extends Thread { public static List<Integer> list = new ArrayList<>();//线程不安全的 @Override public void run() { for (int i = 0; i < 10000; i++) { list.add(i); } System.out.println("添加完毕！"); } }- 定义测试类：
public class Demo { public static void main(String[] args) throws InterruptedException { MyThread t1 = new MyThread(); MyThread t2 = new MyThread(); t1.start(); t2.start(); Thread.sleep(1000); System.out.println("最终集合的长度：" + MyThread.list.size()); } }最终结果可能会抛异常，或者最终集合大小是不正确的。
-
CopyOnWriteArrayList是线程安全的：
- 定义线程类：
public class MyThread extends Thread { // public static List<Integer> list = new ArrayList<>();//线程不安全的 //改用：线程安全的List集合: public static CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<>(); @Override public void run() { for (int i = 0; i < 10000; i++) { list.add(i); } System.out.println("添加完毕！"); } }- 测试类：
public class Demo { public static void main(String[] args) throws InterruptedException { MyThread t1 = new MyThread(); MyThread t2 = new MyThread(); t1.start(); t2.start(); Thread.sleep(1000); System.out.println("最终集合的长度：" + MyThread.list.size()); } }结果始终是正确的。
CopyOnWriteArraySet
-
HashSet仍然是线程不安全的：
- 线程类：
public class MyThread extends Thread { public static Set<Integer> set = new HashSet<>();//线程不安全的 @Override public void run() { for (int i = 0; i < 10000; i++) { set.add(i); } System.out.println("添加完毕！"); } }- 测试类：
public class Demo { public static void main(String[] args) throws InterruptedException { MyThread t1 = new MyThread(); t1.start(); //主线程也添加10000个 for (int i = 10000; i < 20000; i++) { MyThread.set.add(i); } Thread.sleep(1000 * 3); System.out.println("最终集合的长度：" + MyThread.set.size()); } }最终结果可能会抛异常，也可能最终的长度是错误的！！
-
CopyOnWriteArraySet是线程安全的：
- 线程类：
public class MyThread extends Thread { // public static Set<Integer> set = new HashSet<>();//线程不安全的 //改用：线程安全的Set集合: public static CopyOnWriteArraySet<Integer> set = new CopyOnWriteArraySet<>(); @Override public void run() { for (int i = 0; i < 10000; i++) { set.add(i); } System.out.println("添加完毕！"); } }- 测试类：
public class Demo { public static void main(String[] args) throws InterruptedException { MyThread t1 = new MyThread(); t1.start(); //主线程也添加10000个 for (int i = 10000; i < 20000; i++) { MyThread.set.add(i); } Thread.sleep(1000 * 3); System.out.println("最终集合的长度：" + MyThread.set.size()); } }可以看到结果总是正确的！！
ConcurrentHashMap
-
HashMap是线程不安全的。
- 线程类：
public class MyRunnable implements Runnable { // HashMap线程不安全 HashMap<Integer,Integer> map = new HashMap<>();// 2条线程共享的map集合 // Hashtable线程安全 //Hashtable<Integer,Integer> map = new Hashtable<>();// 2条线程共享的map集合 // ConcurrentHashMap线程安全 //ConcurrentHashMap<Integer,Integer> map = new ConcurrentHashMap<>();// 2条线程共享的map集合 @Override public void run() { for (int i = 0; i < 1000; i++) { map.put(i,i); } System.out.println("添加完毕"); } }- 测试类：
public class Test { public static void main(String[] args) throws InterruptedException { /* ConcurrentHashMap: - 演示HashMap线程不安全 - 演示Hashtable线程安全 - 演示ConcurrentHashMap线程安全 案例: 线程1对HashMap集合添加1000个键值对,线程2也对HashMap集合添加1000个键值对 */ // 创建MyRunnable任务对象 MyRunnable mr = new MyRunnable(); // 创建2条线程执行任务 Thread t1 = new Thread(mr); t1.start(); Thread t2 = new Thread(mr); t2.start(); Thread.sleep(2000); System.out.println("最终map集合键值对的个数:"+mr.map.size()); /* 根据分析,共享的map集合中的键值对个数应该是1000个,但实际运行的结果是大于1000的 */ } }运行结果可能会出现异常、或者结果不准确！！
-
Hashtable是线程安全的，但效率低：
改用JDK提供的一个早期的线程安全的Hashtable类来改写此例，注意：加入了"计时"。
- 线程类：
public class MyRunnable implements Runnable { // Hashtable线程安全 Hashtable<Integer,Integer> map = new Hashtable<>();// 2条线程共享的map集合 @Override public void run() { for (int i = 0; i < 1000; i++) { map.put(i,i); } System.out.println("添加完毕"); } }- 测试类：
public class Test { public static void main(String[] args) throws InterruptedException { // 创建MyRunnable任务对象 MyRunnable mr = new MyRunnable(); // 创建1000条线程 for (int i = 0; i < 1000; i++) { Thread t = new Thread(mr); t.start(); } Thread.sleep(5000); System.out.println("最终map集合键值对的个数:"+mr.map.size()); /* 根据分析,共享的map集合中的键值对个数应该是1000个,但实际运行的结果是大于1000的 */ } }能看到结果是正确的，但耗时较长。
-
改用ConcurrentHashMap
- 线程类：
public class MyRunnable implements Runnable { // ConcurrentHashMap线程安全 ConcurrentHashMap<Integer,Integer> map = new ConcurrentHashMap<>();// 2条线程共享的map集合 @Override public void run() { for (int i = 0; i < 1000; i++) { map.put(i,i); } System.out.println("添加完毕"); } }- 测试类：
public class Test {
public static void main(String[] args) throws InterruptedException {
// 创建MyRunnable任务对象
MyRunnable mr = new MyRunnable();
// 创建1000条线程
for (int i = 0; i < 1000; i++) {
Thread t = new Thread(mr);
t.start();
}
Thread.sleep(5000);
System.out.println("最终map集合键值对的个数:"+mr.map.size());
/*
根据分析,共享的map集合中的键值对个数应该是1000个,但实际运行的结果是大于1000的
*/
}
}
可以看到效率提高了很多！！！
- HashTable效率低下原因：
public synchronized V put(K key, V value)
public synchronized V get(Object key)
HashTable容器使用synchronized来保证线程安全，但在线程竞争激烈的情况下HashTable的效率非常低下。因为当一个线程访问HashTable的同步方法，其他线程也访问HashTable的同步方法时，会进入阻塞状态。如线程1使用put进行元素添加，线程2不但不能使用put方法添加元素，也不能使用get方法来获取元素，所以竞争越激烈效率越低。
ConcurrentHashMap高效的原因：CAS + 局部(synchronized)锁定
CountDownLatch
CountDownLatch允许一个或多个线程等待其他线程完成操作。
例如：线程1要执行打印：A和C，线程2要执行打印：B，但线程1在打印A后，要线程2打印B之后才能打印C，所以：线程1在打印A后，必须等待线程2打印完B之后才能继续执行。
CountDownLatch构造方法:
public CountDownLatch(int count)// 初始化一个指定计数器的CountDownLatch对象
CountDownLatch重要方法:
public void await() throws InterruptedException// 让当前线程等待
public void countDown() // 计数器进行减1
- 示例
1). 制作线程1：
public class MyRunnable1 implements Runnable {
CountDownLatch cdl;
public MyRunnable1(CountDownLatch cdl) {
this.cdl = cdl;
}
@Override
public void run() {
System.out.println("A");
// 暂停,等待线程2执行打印B,执行完回到这里来执行打印C
try {
cdl.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("C");// 打印C之前一定要去执行打印B
}
}
2). 制作线程2：
public class MyRunnable2 implements Runnable {
CountDownLatch cdl;
public MyRunnable2(CountDownLatch cdl) {
this.cdl = cdl;
}
@Override
public void run() {
System.out.println("B");
// 计数器-1
cdl.countDown();// 计数器的值为0
}
}
3).制作测试类：
public class Test {
public static void main(String[] args) throws InterruptedException {
/*
CountDownLatch:
作用: 允许一个或多个线程等待其他线程完成操作。
常用方法:
public CountDownLatch(int count)// 初始化一个指定计数器的CountDownLatch对象
public void await() throws InterruptedException// 让当前线程等待
public void countDown() // 计数器进行减1
案例演示:
线程1的任务是打印A和C,线程2的任务是打印B,要求打印B一定要在打印C的前面
*/
CountDownLatch cdl = new CountDownLatch(1);
// 创建2条线程,执行任务
MyRunnable1 mr1 = new MyRunnable1(cdl);
Thread t1 = new Thread(mr1);
t1.start();
MyRunnable2 mr2 = new MyRunnable2(cdl);
Thread t2 = new Thread(mr2);
t2.start();//
}
}
4). 执行结果：
会保证按：A B C的顺序打印。
说明：
CountDownLatch中count down是倒数的意思，latch则是门闩的含义。整体含义可以理解为倒数的门栓，似乎有一点“三二一，芝麻开门”的感觉。
CountDownLatch是通过一个计数器来实现的，每当一个线程完成了自己的任务后，可以调用countDown()方法让计数器-1，当计数器到达0时，调用CountDownLatch。
await()方法的线程阻塞状态解除，继续执行。
CyclicBarrier
CyclicBarrier的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。
例如：公司召集5名员工开会，等5名员工都到了，会议开始。创建5个员工线程，1个开会线程，几乎同时启动，使用CyclicBarrier保证5名员工线程全部执行后，再执行开会线程。
CyclicBarrier构造方法：
public CyclicBarrier(int parties, Runnable barrierAction
//parties: 代表要达到屏障的线程数量
//barrierAction:表示达到屏障后要执行的线程
CyclicBarrier重要方法：
public int await()// 每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞
- 示例代码：
1). 制作员工线程：
public class MyRunnable implements Runnable {
CyclicBarrier cb;
public MyRunnable(CyclicBarrier cb) {
this.cb = cb;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+":到会议室了...");
// 当前线程到达会议室(屏障),暂停
try {
cb.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":离开会议室");
}
}
2). 制作开会线程：
public class MeetingRunnable implements Runnable {
@Override
public void run() {
System.out.println("会议开始,会议的内容是...");
}
}
3). 制作测试类：
public class Test {
public static void main(String[] args) {
/*
CyclicBarrier类:
作用:它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，
所有被屏障拦截的线程才会继续运行。
常用方法:
public CyclicBarrier(int parties, Runnable barrierAction)
parties: 代表要达到屏障的线程数量
barrierAction:表示达到屏障后要执行的线程
public int await() 每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞
案例演示:
例如：公司召集5名员工开会，等5名员工都到了，会议开始
*/
// 创建CyclicBarrier对象
CyclicBarrier cb = new CyclicBarrier(5,new MeetingRunnable());
MyRunnable mr = new MyRunnable(cb);
new Thread(mr,"员工1").start();
new Thread(mr,"员工2").start();
new Thread(mr,"员工3").start();
new Thread(mr,"员工4").start();
new Thread(mr,"员工5").start();
}
}
4). 执行结果：
使用场景
使用场景：CyclicBarrier可以用于多线程计算数据，最后合并计算结果的场景。
需求：使用两个线程读取2个文件中的数据，当两个文件中的数据都读取完毕以后，进行数据的汇总操作。
Semaphore
Semaphore的主要作用是控制线程的并发数量。
synchronized可以起到"锁"的作用，但某个时间段内，只能有一个线程允许执行。
Semaphore可以设置同时允许几个线程执行。
Semaphore字面意思是信号量的意思，它的作用是控制访问特定资源的线程数目。
Semaphore构造方法：
public Semaphore(int permits) permits 表示许可线程的数量
Semaphore重要方法：
public void acquire() throws InterruptedException 表示获取许可
public void release() release() 表示释放许可
- 示例一：同时允许1个线程执行
1). 制作一个ClassRoom类：
public class ClassRoom {
// 创建Semaphore对象,指定线程的并发数量是1
Semaphore sp = new Semaphore(2);
public void into(){
// 获得许可证,才进来了
try {
sp.acquire();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":进来了...");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 出去了,就释放许可
System.out.println(Thread.currentThread().getName()+":出去了...");
sp.release();
}
}
2). 制作线程类：
public class MyRunnable implements Runnable {
ClassRoom cr;
public MyRunnable(ClassRoom cr) {
this.cr = cr;
}
@Override
public void run() {
cr.into();// 任务就是进入教室
}
}
3). 测试类：
public class Test {
public static void main(String[] args) {
/*
Semaphore类:
作用: 控制线程的并发数量。
常用方法:
public Semaphore(int permits) permits 表示许可线程的数量
public void acquire() throws InterruptedException 表示获取许可
public void release() release() 表示释放许可
案例演示:
假设有个教室,只能容纳3个人,这个时候有5个人需要进来
*/
ClassRoom cr = new ClassRoom();
// 创建5条线程,执行任务
MyRunnable mr = new MyRunnable(cr);
new Thread(mr,"1号").start();
new Thread(mr,"2号").start();
new Thread(mr,"3号").start();
new Thread(mr,"4号").start();
new Thread(mr,"5号").start();
}
}
Exchanger
Exchanger（交换者）是一个用于线程间协作的工具类。Exchanger用于进行线程间的数据交换。
这两个线程通过exchange方法交换数据，如果第一个线程先执行exchange()方法，它会一直等待第二个线程也执行exchange方法，当两个线程都到达同步点时，这两个线程就可以交换数据，将本线程生产出来的数据传递给对方。
A线程 exchange方法 把数据传递B线程
B线程 exchange方法 把数据传递A线程
Exchanger构造方法：
public Exchanger()
Exchanger重要方法：
public V exchange(V x)
- 示例一
public class MyRunnable1 implements Runnable {
Exchanger<String> ex;
public MyRunnable1(Exchanger<String> ex) {
this.ex = ex;
}
@Override
public void run() {
// 线程1 传递数据给 线程2
try {
// 线程1,把"信息1"传递给线程2
String message2 = ex.exchange("信息1");
System.out.println("线程2 传递给 线程1的信息是:"+message2);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class MyRunnable2 implements Runnable {
Exchanger<String> ex;
public MyRunnable2(Exchanger<String> ex) {
this.ex = ex;
}
@Override
public void run() {
// 线程2 传递数据给 线程1
try {
String message1 = ex.exchange("信息2");
System.out.println("线程1 传递给 线程2的信息:"+message1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
2). 制作main()方法：
public class Test {
public static void main(String[] args) {
/*
Exchanger类:
作用:是一个用于线程间协作的工具类。Exchanger用于进行线程间的数据交换。
常用方法:
public Exchanger()
public V exchange(V x) 参数就表示当前线程需要传递的数据,返回值是其他线程传递过来的数据
案例演示:
*/
Exchanger<String> ex = new Exchanger<>();
MyRunnable1 mr1 = new MyRunnable1(ex);
new Thread(mr1).start();
MyRunnable2 mr2 = new MyRunnable2(ex);
new Thread(mr2).start();
}
}
使用场景：可以做数据校对工作
需求：比如需要将纸制银行流水通过人工的方式录入成电子银行流水。为了避免错误，采用AB岗两人进行录入，录入到两个文件中，系统需要加载这两个文件，并对两个文件数据进行校对，看看是否录入一致。
226
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
