01 进程与线程的区别
进程：是正在执行的一段程序，一旦程序被载入内存准备执行，那就是一个进程。进程是表示资源分配的基本概念，又是调度运算的基本单位，是系统的并发执行单元。
线程：单个进程中执行的每个任务都是一个线程，线程是进程中执行运算的最小单位。
线程的意义：提高程序效率，充分发挥多和计算机的优势。
02 多线程创建
1，继承Thread类，实现run();
public static class MyThread extends Thread{
@Override
public void run() {
System.out.println("我的一个线程");
}
}
public static void main(String[] args) {
MyThread t = new MyThread();
t.start();
}
2，实现Runnable接口，将对象做为Thread的构造参数传入
public static class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println("我的一个线程");
}
}
public static void main(String[] args) {
Thread t = new Thread(new MyRunnable());
t.start();
}
还有比较灵活的写法：
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("匿名内部类写法");
}
});
//JDK1.8版本以后
Thread t2 = new Thread(()->{
System.out.println("兰姆达表达式");
});
t1.start();
t2.start();
3，实现Callable接口的call()，允许线程执行完以后获取返回结果
public static class MyCall implements Callable<String> {
@Override
public String call() throws Exception {
return "返回结果";
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask<String> task = new FutureTask<String>(new MyCall());
Thread thread = new Thread(task);
thread.start();
System.out.println(task.get());
}
03 用户线程与守护线程
当JVM运行起来以后，会有两种线程：用户线程与守护线程。
JVM关闭的条件：当用户线程运行完毕后，即使存在守护线程，它也会关闭。所以不能绝对的说：用户线程和守护线程都运行完毕了JVM才关闭。
在Java里有个很出名的守护线程就是：GC垃圾回收线程。
做一个小测试：
public static void main(String[] args) throws ExecutionException, InterruptedException {
Thread thread1 = new Thread(()->{
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程1："+i);
}
});
//守护线程
thread1.setDaemon(true);
thread1.start();
//用户线程
Thread thread2 = new Thread(()->{
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程2："+i);
}
});
thread2.start();
}
输出结果：
线程2：94
线程2：95
线程1：25
线程2：96
线程2：97
线程2：98
线程1：26
线程2：99
Process finished with exit code 0
上面的thread1.setDaemon(true);设置成了守护线程，当用户线程结束后，守护线程也停止运行了。
04 线程的优先级
CPU内核同一时刻只能执行一条线程，内核靠线程调度器来分配时间片来执行线程。所以线程需要抢夺时间片来执行，那么优先级其实就是设置抢夺的概率。
public static void main(String[] args){
Thread thread1 = new Thread(()->{
for (int i = 0; i < 100; i++) {
System.out.println("线程1："+i);
}
});
Thread thread2 = new Thread(()->{
for (int i = 0; i < 100; i++) {
System.out.println("线程2："+i);
}
});
thread1.setPriority(10);
thread2.setPriority(5);
thread1.start();
thread2.start();
}
输出结果：
线程1：97
线程1：98
线程1：99
线程2：0
线程2：1
线程2：2
线程2：3
线程2：4
可以看到线程1执行完毕后线程2才开始执行，说明线程1争夺时间片的概率大。
05 线程的生命周期
线程的生命周期
06 join方法
在线程执行的时候让别的线程调用join先插队，等别的线程执行完后再执行本线程。
public static void main(String[] args){
Thread t1 = new Thread(()->{
for (int i = 0; i < 3; i++) {
System.out.println("t1："+i);
}
});
Thread t2 = new Thread(()->{
try {
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 0; i < 3; i++) {
System.out.println("t2："+i);
}
});
Thread t3 = new Thread(()->{
try {
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 0; i < 3; i++) {
System.out.println("t3："+i);
}
});
t1.start();
t2.start();
t3.start();
}
输出结果：
t1：0
t1：1
t1：2
t2：0
t2：1
t2：2
t3：0
t3：1
t3：2
Process finished with exit code 0
07 JMM内存模型
JMM（Java Memory Model）
JMM内存模型
线程是不能够直接修改主存内的数据的，而是先从主存中读取到自己的工作内存中创建副本，修改完成后写入到主内存，这就是JMM模型。
这也是为什么多线程并发访问修改数据的时候为什么出现安全问题。
08 并发编程的三大特性
原子性
一个操作或多个操作，要么全部执行并且执行过程不被打断，要么全部不执行（提供互斥访问，在同一时刻只有一个线程进行访问）
可以通过加锁的方式。
先看不加锁：
static int num = 100;
public static void main(String[] args){
Runnable runnable = ()->{
while (true){
if(num>0){
num--;
}else{
break;
}
System.out.println(num);
}
};
new Thread(runnable).start();
new Thread(runnable).start();
new Thread(runnable).start();
}
输出了诡异的结果：
1
0
98
94
Process finished with exit code 0
如果加锁：
static int num = 100;
public static void main(String[] args){
Object o = new Object();
Runnable runnable = ()->{
while (true){
synchronized (o){
if(num>0){
num--;
}else{
break;
}
System.out.println(num);
}
}
};
new Thread(runnable).start();
new Thread(runnable).start();
new Thread(runnable).start();
}
输出结果：
5
4
3
2
1
0
Process finished with exit code 0
加锁需要传入一个对象，本程序中该对象是唯一的，如果直接写new Object()和不加锁效果一样。
可见性
public static boolean flag = false;
public static void main(String[] args) throws InterruptedException {
new Thread(()->{
System.out.println("线程一号启动");
while (!flag){};
System.out.println("线程一号结束");
}).start();
Thread.sleep(1000);
new Thread(()->{
flag = true;
System.out.println("把flag修改为了true");
}).start();
}
显然对于一号线程而言，当二号线程修改了flag的值后，一号线程并没有及时获得flag，也就是说flag对于一号线程是不可见的。flag的值没有得到及时的更新。
有序性
JVM为了提高效率，会做出一些优化，对指令进行重排序（happens-before），在单线程的情况下没有问题，但是多线程编程需要考虑有序性问题。
volatile
1，保证可见性
2，屏蔽指令重排序
3，但是保证不了原子性
synchronized
JDK1.0开始提供的关键字，重量级的锁，能够保证某个代码块在被执行时，其他线程不访问执行。
synchronized必须使用对象做为锁，因为对象分为三部分：头部分里面有个锁的字段，synchronized就是利用该字段达到上锁的目的。
注意：假如有两个方法，要想实现调用fun1时fun2不能被访问，必须使用同一个对象加锁
public static Object o ;
public static void fun1(){
synchronized (o){}
}
public static void fun2(){
synchronized (o){}
}
Monitor
JVM 是通过进入、退出对象监视器(Monitor)来实现对方法，同步块的同步。
使用synchronized加锁定的代码块，在被编译后会形成对象监视器的入口(monitorenter)和出口(monitorexit)
对象监视器
使用对象Object做为锁的时候，当有线程访问同步代码块的时候，监视器入口(monitorenter)会去检查Object是否上锁，没有上锁，则让该线程访问，同时给该对象上锁，此时若有其他线程访问该代码块的时候，监视器入口通过对比Object，发现上锁了，就会让其他线程处于阻塞状态，当第条线程执行完毕退出(monitorexir)以后，会给该对象解锁，那么被阻塞的线程就可以接着访问，并保证了原子性。
public class Demo {
public static synchronized void get(){
//是把Demo.class(当前类的字节码文件)做为对象加锁
}
public synchronized void to(){
//是把this(当前this锁)做为对象枷锁
}
public static void main(String[] args) {
Demo demo = new Demo();
demo.to();
Demo.get();
}
}
对象如同锁，持有锁的线程可以在同步中执行，没有持有锁的线程，即使获取CPU的执行权，也进不去。
优点：解决了线程安全问题
缺点：多个线程需要判断锁，较为消耗资源，抢锁的资源
09 J.U.C之Lock
Lock
public static void main(String[] args) {
Lock lock = new ReentrantLock();
//Lock是代码实现的接口，而synchronized是JVM底层实现的
new Thread(()->{
lock.lock();
try{
//加锁代码块
}finally {
//必须手动释放
lock.unlock();
}
}).start();
}
trylock
上锁部分不被访问的时候，去做别的事情，而不是像synchronized那样必须阻塞。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Demo {
Lock lock = new ReentrantLock();
public void insert(Thread thread){
if(lock.tryLock()){
//抢到锁了，就调用这里的方法
try{
System.out.println(thread.getName()+"抢到锁啦");
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
System.out.println(thread.getName()+"释放锁啦");
}
}else{
//如果没有抢到锁，就调用这里的方法
System.out.println(Thread.currentThread()+"没有抢到锁啦");
}
}
public static void main(String[] args) {
Demo d = new Demo();
new Thread(()->{
d.insert(Thread.currentThread());
}).start();
new Thread(()->{
d.insert(Thread.currentThread());
}).start();
}
}
Lock与synchronized的区别
1）Lock是一个接口，而synchronized是一个关键字，是Java内置的实现，它可以直接修饰方法和代码块，而lock只能修饰代码块。
2）synchronized在发生异常的时候，会自动释放线程占有的锁，因此不会导致死锁现象，而Lock发生异常以后，如果没有unLock()释放锁，很可能造成死锁现象，因此在使用Lock的时候需要在finally中释放锁。
3）Lock可以让等待的线程响应中断，去干别的事情，而synchronized会让线程一直阻塞下去。
4）通过Lock的trylock()可以知道有没有成功获取锁，而synchronized不行。
5）Lock可以提高多线程进行读操作的效率（提供读写锁）。
从性能上来说，如果竞争资源很激烈，Lock的性能远远大于synchronized。
10 线程通信
wait与notify使用两个线程交替打印1-100，其中一条线程只打印奇数，另外一个线程只打印偶数。
public class Wait {
static class Num{
public int num = 1;//共享资源
}
static class J implements Runnable{
public Num numObj;
public J(Num n){
this.numObj = n;
}
@Override
public void run() {
synchronized (numObj){
while (numObj.num<=100){
if(numObj.num%2!=0){
System.out.println("奇数====>"+numObj.num);
numObj.num++;
}else {
try {
numObj.notify();
numObj.wait();//wait()要写在代码块里面，因为它的作用是释放锁，并且等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
static class O implements Runnable{
public Num numObj;
public O(Num n){
this.numObj = n;
}
@Override
public void run() {
synchronized (numObj){
while (numObj.num<=100) {
if (numObj.num % 2 == 0) {
System.out.println("偶数====>" + numObj.num);
numObj.num++;
} else {
try {
numObj.notify();
numObj.wait();//wait()要写在代码块里面，因为它的作用是释放锁，并且等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
public static void main(String[] args) {
Num numObj = new Num();
new Thread(new J(numObj)).start();//奇数线程
new Thread(new O(numObj)).start();//偶数线程
}
}
wait()的作用是，释放当前锁，并使当前线程处于等待状态，所以需要写在同步代码块里，notify()是唤醒一个处于等待状态的线程，本题只有两条线程，如果有多条线程，那么可以使用notifyAll()。
这三个方法最终调用的都是JVM级的native方法。
11 什么是线程池
线程池是Java的并发框架，几乎所有的并发执行程序或者异步操作都可以使用线程池。
1）降低资源消耗。通过重复使用已经创建好的线程降低创建和销毁的消耗。
2）提高响应速度。当任务到达时，不需要等到线程创建后就可以立即执行。
3）提高现成的可管理性。使用线程池可以进行统一的分配、调优、监控。
12 线程池工作原理
Executor是最基本的接口，其子接口：ExecutorService是工作中常用的接口
其中一个很重要的实现类是ThreadPoolExecutor，通过它new出来
import java.util.concurrent.*;
public class Pool {
static class MyRunnable implements Runnable{
String info = "";
public MyRunnable(String txt){
this.info = txt;
}
@Override
public void run() {
System.out.println(this.info);
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
// int corePoolSize 核心线程数
// int maximumPoolSize 最大线程数
// long keepAliveTime 保持存活得时间
// TimeUnit unit 时间单位
// BlockingQueue<Runnable> workQueue 任务队列
// RejectedExecutionHandler handler 饱和策略
ExecutorService es = new ThreadPoolExecutor(
2,//corePoolSize
5,//maximumPoolSize
10,//keepAliveTime
TimeUnit.SECONDS,//unit
new ArrayBlockingQueue<Runnable>(5),
new ThreadPoolExecutor.AbortPolicy());
for (int i = 1; i <= 20; i++) {
try{
es.execute(new MyRunnable("执行第"+i+"条线程"));
}catch (Throwable e){
System.out.println("丢弃线程"+i);
}
}
es.shutdown();
}
}
线程池
四个流程：
1）判断核心线程数
2）判断任务队列
3）判断最大线程数（备胎线程）
4）执行饱和策略
存活时间参数：当最大线程数（备胎线程）执行完毕，并且没有新任务的前提下，只能存活（keepAliveTime unit ）的时间，超过时间就会被释放掉。
13 三种常见队列
SynchronousQueue
一次性只能装一个任务，其他任务处于阻塞状态，同时一次性只能取出一个任务，如果没有任务可以取出，也处于阻塞状态
import java.util.concurrent.SynchronousQueue;
public class Queue {
public static void main(String[] args) {
SynchronousQueue<Integer> queue = new SynchronousQueue<>();
new Thread(()->{
for (int i = 0; i < 20; i++) {
try {
queue.put(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("装入数据====>"+i);
}
}).start();
new Thread(()->{
for (int i = 0; i < 20; i++) {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
System.out.println("取出数据=====>"+queue.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
//执行结果
取出数据=====>0
装入数据====>0
隔了两秒
取出数据=====>1
装入数据====>1
隔了两秒
取出数据=====>2
装入数据====>2‘
隔了两秒
取出数据=====>3
装入数据====>3
LinkedBlockingQueue
瞬间装完所有的任务，然后慢慢取出
import java.util.concurrent.LinkedBlockingQueue;
public class Queue {
public static void main(String[] args) {
LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
new Thread(()->{
for (int i = 0; i < 20; i++) {
try {
queue.put(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("装入数据====>"+i);
}
}).start();
new Thread(()->{
for (int i = 0; i < 20; i++) {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
System.out.println("取出数据=====>"+queue.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
//执行结果
装入数据====>18
装入数据====>19
瞬间装完20个数据
取出数据=====>0
隔了两秒
取出数据=====>1
隔了两秒
取出数据=====>2
隔了两秒
取出数据=====>3
ArrayBlockingQueue
设置填装大小，比如4，那么一次性装入4个，其余的取出一个就装一个
import java.util.concurrent.ArrayBlockingQueue;
public class Queue {
public static void main(String[] args) {
ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(4);
new Thread(()->{
for (int i = 0; i < 20; i++) {
try {
queue.put(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("装入数据====>"+i);
}
}).start();
new Thread(()->{
for (int i = 0; i < 20; i++) {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
System.out.println("取出数据=====>"+queue.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
//执行结果
装入数据====>0
装入数据====>1
装入数据====>2
装入数据====>3
瞬间完成
取出数据=====>0
装入数据====>4
隔了两秒
取出数据=====>1
装入数据====>5
隔了两秒
14 饱和策略
CallerRunsPolicy
不抛弃任务，调用线程池的线程，帮助执行任务
比如上面的main方法调用的线程池，16号线程就会在main中执行
演示代码：
import java.util.concurrent.*;
public class Pool {
static class MyRunnable implements Runnable{
String info = "";
public MyRunnable(String txt){
this.info = txt;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+":"+this.info);
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
ExecutorService es = new ThreadPoolExecutor(
2,
5,
10,
TimeUnit.SECONDS,
new ArrayBlockingQueue<Runnable>(10),
new ThreadPoolExecutor.CallerRunsPolicy());
for (int i = 1; i <= 20; i++) {
try{
es.execute(new MyRunnable("执行第"+i+"条线程"));
}catch (Throwable e){
System.out.println("丢弃线程"+i);
}
}
es.shutdown();
}
}
执行结果：
pool-1-thread-2:执行第2条线程
pool-1-thread-1:执行第1条线程
main:执行第16条线程
pool-1-thread-3:执行第13条线程
pool-1-thread-4:执行第14条线程
pool-1-thread-5:执行第15条线程
AbortPolicy（默认）
当最大线程数满了以后，抛出异常，抛弃任务
DiscardPolicy
连异常都不抛，直接把任务丢了
DiscardOldestPolicy
连异常都不抛，直接把任务丢了
15 线程池工具类
工具类：Executors 快速创建线程池
缓存线程池
newCachedThreadPool
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Es {
public static void main(String[] args) {
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
System.out.println("线程"+i);
executorService.execute(()->{
for (int j = 0; j < 5; j++) {
System.out.println(Thread.currentThread().getName()+":"+j);
}
});
}
executorService.shutdown();
}
}
源码的实现：
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
可以发现：没有核心线程数，扔进去多少线程，就会创建多少线程，好处是线程复用以及可以及时释放线程，弊端就是，当任务量极大的时候，他就创建一大堆线程。
定长线程池
newFixedThreadPool
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Es {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(2);
for (int i = 0; i < 10; i++) {
System.out.println("线程"+i);
executorService.execute(()->{
for (int j = 0; j < 5; j++) {
System.out.println(Thread.currentThread().getName()+":"+j);
}
});
}
executorService.shutdown();
}
}
源码的实现：
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
单例线程池
newSingleThreadExecutor
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Es {
public static void main(String[] args) {
ExecutorService executorService = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
System.out.println("线程"+i);
executorService.execute(()->{
for (int j = 0; j < 5; j++) {
System.out.println(Thread.currentThread().getName()+":"+j);
}
});
}
executorService.shutdown();
}
}
可以发现单例线程池，会由一个线程完成所有的任务。
源码的实现：
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
调度线程池
ScheduledExecutorService：newScheduledThreadPool
可以实现：延迟执行的线程池
public static void main(String[] args) {
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
//延迟执行的线程池
scheduledExecutorService.schedule(()->{
System.out.println("过去5秒种啦");
},5, TimeUnit.SECONDS);//第二个参数是延迟时间，然后是时间单位
scheduledExecutorService.shutdown();
}
可以实现：周期执行的线程池
public static void main(String[] args) {
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
//周期执行的线程池：5s之后开始执行任务，每隔2s重复执行一次
scheduledExecutorService.scheduleAtFixedRate(()->{
System.out.println("执行啦");
},5,2, TimeUnit.SECONDS);//参数：延迟时间 间隔时间 时间单位
//scheduledExecutorService.shutdown();这时候不要shutdown
}
网友评论