文章目录
线程创建
线程创建有三种方式：
- 实现Runnable接口的run方法
- 继承Thread类并重写run方法
- 实现Callable接口,使用FutureTask方式
继承Thread类并重写run方法
package threadtxt;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class ThreadTest {
/***
* 继承Thread 类并重写run方法
*/
public static class MyThread extends Thread{
@Override
public void run() {
System.out.println("i am a child thread");
}
}
public static void main(String[] args) {
// 创建线程
MyThread myThread = new MyThread();
// 启动线程
myThread.start();
}
}
注意点:
当线程创建完thread对象后该线程并没有启动，直到调用了start方法才真正的启动了线程。调用start方法后线程没有马上执行，而是进入了就绪状态，这个时候已经获取了除CPU资源外的其他资源，等待获取CPU资源后才会真正处于运行状态。run方法执行完毕之后，该线程就处于终止状态。
实现Runnable接口的run方法
package threadtxt;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class ThreadTest {
/***
* 实现Runnable接口
*/
public static class RunableTask implements Runnable{
@Override
public void run() {
System.out.println("i am a child thread");
}
}
public static void main(String[] args) {
RunableTask runableTask = new RunableTask();
new Thread(runableTask).start();
new Thread(runableTask).start();
}
}
实现Callable接口,使用FutureTask方式
package threadtxt;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class ThreadTest {
/***
* 使用FutureTask方式实现
*/
public static class CallerTask implements Callable<String>{
@Override
public String call() throws Exception {
return "hello";
}
}
public static void main(String[] args) {
// 创建异步任务
FutureTask<String> futureTask = new FutureTask<>(new CallerTask());
// 创建线程并启动
new Thread(futureTask).start();
try {
// 等待任务执行完毕，返回结果
String rtn = futureTask.get();
System.out.println(rtn);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
知识点
在程序里面调用start方法后，虚拟机会先为我们创建一个线程，然后等到这个线程第一次得到时间片时再调用run()方法。但是不可多次调用start方法，在第一次调用start方法后，再次调用start方法会抛出异常，因为start方法中在使用前会先判断threadStatus变量是否为0，如果不为0则抛出异常
线程通知与等待
Java多线程的等待/通知机制是基于Object类的wait()方法和notify()、notifyAll()方法来实现。
notify()方法会随机唤醒一个正在等待的线程，而notifyAll()会叫醒所有正在等待的线程
线程调用wait方法时，该线程就会被阻塞挂起，直到发生下面几件才会返回：
- 其他线程调用了该共享对象的notify()或者notifyAll()方法
- 其他线程调用了该线程的interrupt()方法，该线程抛出InterruptedException异常返回
知识点
调用wait方法的线程没有事先获取该对象的监视器锁，则调用wait方法时，会抛出illegalMonitorStateException异常
问题1：一个线程如何才能获取一个共享变量的监视器锁？
(1) 执行synchronized同步代码块时，使用该共享变量作为参数
synchronized(共享变量){
//业务逻辑
}
(2)调用该共享变量的方法，并且该犯法使用了synchronized修饰
synchronized void add(int a,int b){
//业务逻辑
}
虚假唤醒
一个线程从挂起状态变为运行状态(被唤醒)，即使该线程没有被其他线程调用notify()、notifyAll()方法进行通知，或者是被中断、或者等待超时
问题1：怎么防止虚假唤醒？
不停的去测试该线程被唤醒的条件是否满足，不满足则继续等待，即是在一个循环中调用wait方法进行防范。退出循环的条件是满足了唤醒该线程的条件。
synchronized(obj){
while(条件是否满足){
obj.wait();
}
}
以上代码中的while()循环，则不能用if代替，如果使用if则只会判断一次，当下次条件不满足时 ，线程也会唤醒。所以等待应该出现在循环当中
一般并发线程操作的步骤:
- 判断等待
- 业务操作
- 通知
知识点
当前线程调用共享变量wait方法后只会释放当前变量上的锁，如果当前线程还持有其他共享变量锁，则这些锁是不会被释放的。
wait()、wait(long timeout)、wait(long timeout,int nanous)函数
wait(long timeout)相比wait()方法多了一个超时参数，如果一个线程调用共享对象的该方法挂起后，没有在指定的timeout ms 时间内被其他线程调用该共享变量的notify()或者notifyAll()方法唤醒，那么该函数还是会因为超时而返回。
知识点
wait(0)方法和wait()方法效果一样，因为在wait方法内部就是调用了wait(0)。需要注意的是，如果在调用函数时，传递了一个负的timeout则会抛出illegalArgumentException异常。
notify()、notifyAll()函数
线程调用notify()方法后，会唤醒一个在该共享变量上调用wait系列方法后被挂起的线程。
知识点
- 一个共享变量上可能会有多个线程在等待，具体唤醒哪个等待的线程是随机的。
- 被唤醒的线程不能马上从wait方法返回并继续执行，它必须在获取了共享对象的监视器锁后才可以返回，也就是唤醒它的线程释放了共享变量上的监视器锁后，被唤醒的线程也不一定会获取到该共享对象的监视器锁，因为其他线程会和当前线程一起竞争该锁，只有该线程竞争到了共享变量的监视器锁后才可以继续执行。
- 只有当前线程获取到了共享变量的监视器锁后，才可以调用该共享变量的notify方法，否会抛出illegalMontitorStateException异常。
notifyAll方法则会唤醒所有在该共享变量上由于调用wait系列方法而被挂起的线程。
等待线程执行终止的join方法
怎么快速理解下线程中join()方法？？？
想象一下，你现在在排队买奶茶，快要到你的时候，突然来个非常漂亮的妹子说：帅哥，可以让我先买吗？（这个时候想，长得还可以，让你先买吧，等你买完就到我了，说不定让你先买，还能留个微信号，交个朋友），然后你说：可以啊，于是妹子站在你前面买奶茶，可是这个时候，她的七大姑八大姨都来了，都排在那个妹子前面，你从前面的第三位，直接变成第N位。这个时候只能感叹，早知道我就先买了。线程中的join方法就是这个道理了。让其他的线程先执行完毕后，然后自己在执行操作。
举个栗子
package threadtxt2;
import java.util.concurrent.TimeUnit;
public class ThreadTest {
public static void main(String[] args) throws InterruptedException {
Thread tA = new Thread(() -> {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(" child tA over!!! ");
});
Thread tB = new Thread(() -> {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(" child tB over!!! ");
});
tA.start();
tB.start();
System.out.println("wait all child");
//等待子线程执行完毕，返回
tA.join();
tB.join();
System.out.println("over all child");
}
}
返回结果
wait all child
child tB over!!!
child tA over!!!
over all child
知识点
join()方法是Thread 类的一个实例方法。它的作用是让当前线程陷入“等待”状态，等待join的这个线程执行完成后，再继续执行当前线程。
有时候，主线程创建并启动了子线程，如果子线程需要进行大量的耗时运算，主线程往往将早于子线程结束之前结束。
如果主线程想等待子线程执行完毕后，获得子线程中的处理完的某个数据，就要用到join方法
注意点
join()方法由两个重载方法，一个是join(long),一个是join(long,int)。
实际上，通过源码发现，join()方法及其重载方法底层都是利用了wait(long timeout)这个方法
对于join(long,int),通过查看源码(JDK1.8)发现，底层并没有精确到纳秒，而是对第二个参数做了简单的判断和处理
让线程睡眠的sleep方法
当一个执行中的线程调用了Thread的sleep方法后，调用线程会暂时让出指定时间的执行权，也就是在这期间不参与CPU的调度，但是该线程所拥有的监视器资源，比如锁还是持有状态。
指定的睡眠时间到了后该函数就会正常返回，线程处于就绪状态，然后参与CPU调度，获取CPU资源后就可以继续运行了。
知识点
在调用sleep方法的线程，睡眠期间其他线程调用了interrupt()方法中断了该线程，则该线程会在调用sleep方法的地方抛出InterruptedException异常返回
Sleep方法与wait方法区别
- wait方法可以指定等待时间，也可以不指定。Sleep方法必须指定
- wait方法释放CPU资源，同时释放锁。sleep方法释放cpu资源，但是不释放锁。所以容易死锁。
- wait方法必须方法在同步块或同步方法中，而sleep可以放在任意位置
让出CPU执行权的yield方法
当一个线程调用yield方法时，当前线程会让出CPU使用权，然后处于就绪状态，线程调度器会从线程就绪队列里面获取一个线程优先级最高的线程，当然也有可能会调度到刚刚让出CPU的那个线程。
sleep()与yield()区别
当前线程调用sleep方法时调用线程会被阻塞挂起指定的时间，在这期间线程调度器不会去调度其他线程。
调用yield方法时，线程只是让出自己剩余的时间片，并没有挂起，而是出于就绪状态，线程调度器下一次调度时就有可能调度到当前线程执行
线程中断
java中的线程中断是一种线程间的协作模式，线程中断机制是一种协作机制，通过设置线程的中断标志并不能直接终止该线程的执行，而是被中断的线程根据中断状态自行处理。
Thread类里提供的关于线程中断的几个方法:
- Thread.interrupt() : 中断线程。这里的中断线程并不会立即停止线程，而是设置线程的中断状态为true(默认为false);
- Thread.interrupted(): 测试当前线程是否被中断，线程的中断状态受这个方法的影响，意思是调用一次使线程中断设置为true，连续调用两次会使得这个线程的中断状态重新转为false
- Thread.isInterrupted() : 测试当前线程是否被中断，与上面方法不同的是调用这个方法并不会影响线程的中断状态。
在线程的中断机制里，当其他线程通知需要被中断的线程后，线程中断的状态被设置为true，但是具体被要求中断的线程要怎么处理，完全由被中断线程自己而定，可以在适合的实际处理中中断请求，也可以完全不处理继续执行下去。
线程死锁
死锁：指两个或者两个以上的线程在执行过程中，因争夺资源而造成的相互等待的现象。在无外力作用的情况下，这些线程会一直相互等待而无法继续运作下去。
为什么会产生死锁？？
死锁的产生必须满足以下四个条件：
- 互斥条件：指线程对已经获取到的资源进行排它性使用，即该资源同时只有一个线程占用。如果此时还有其他线程请求获取该资源，则请求者只能等待，直至占有资源的线程释放该资源。
- 请求并持有条件：指一个线程已经持有了至少一个资源，但又提出了新的资源请求，而新的资源已被其他线程占有，所以当前线程会被阻塞，但是阻塞的同时并不释放自己已经获取的资源。
- 不可剥夺条件：指线程获取到的资源在自己使用完之前不能被其他线程抢占，只有在自己使用完毕后才由自己释放该资源
- 环路等待：指在发生死锁时， 必然存在一个线程→资源的环形链， 即线程集合{TO , TL T2 ，…， Tn ｝中的TO 正等待一个Tl 占用的资源， Tl 正在等待T2 占用的资源，……Tn 正在等待己被TO 占用的资源。
如何避免线程死锁？
- 对资源进行有序的分配，让获取资源有先后顺序
守护线程与用户线程
Java中的线程分为两类，分别为daemon线程和user线程。
知识点
JVM的退出和用户线程有关，和守护线程无关。只要有一个用户线程没有结束，正常情况下JVM就不会退出。
守护线程默认的优先级比较低。一个线程默认是非守护线程，可以通过Thread类的setDaemon(boolean on )来设置
线程组和线程优先级
线程组
java中用ThreadGroup来表示线程组，我们可以使用线程组对线程进行批量控制。
每个Thread必然存在于一个ThreadGroup中，Thread不能独立于ThreadGroup存在。
ThreadGroup管理着它下面的Thread，ThreadGroup是一个标准的向下引用的树状结构。这样设计的原因是防止上级线程被下级线程引用而无法有效地被GC回收。
线程的优先级
Java中线程优先级可以指定，范围是1~10。但是并不是所有操作系统都支持10级优先级的划分，java只是给操作系统一个优先级参考值，线程最终在操作系统的优先级还是由操作系统决定。
知识点
java默认的线程优先级为5，线程的执行顺序有调度程序来决定，线程的优先级会在线程调用前设定。通常情况下，高优先级的线程比低优先级有更高的几率得到执行。我们使用方法Thread类的setPriority()方法来设定线程的优先级
线程组的常用方法及数据结构
获取当前的线程组名字
Thread.currentThread().getThreadGroup().getName()
复制线程组
//复制一个线程数组到一个线程组
Thread[] threads = new Thread[threadGroup.activeCount()];
ThreadGroup threadGroup = new ThreadGroup();
threadGroup.enumerate(threads);
线程组统一异常处理
public static void main(String[] args){
ThreadGroup threadGroup1 = new ThreadGroup("group1") {
// 继承ThreadGroup并重新定义以下⽅法
// 在线程成员抛出unchecked exception
// 会执⾏此⽅法
public void uncaughtException(Thread t, Throwable e) {
System.out.println(t.getName() + ": " + e.getMessage());
}
};
// 这个线程是threadGroup1的⼀员
Thread thread1 = new Thread(threadGroup1, new Runnable() {
public void run() {
// 抛出unchecked异常
throw new RuntimeException("测试异常");
}
});
thread1.start();
}
线程组的数据结构
线程组还可以包含其他的线程组，不仅仅是线程。
public class ThreadGroup implements Thread.UncaughtExceptionHandler {
private final ThreadGroup parent; // ⽗亲ThreadGroup
String name; // ThreadGroupr 的名称
int maxPriority; // 线程最⼤优先级
boolean destroyed; // 是否被销毁
boolean daemon; // 是否守护线程
boolean vmAllowSuspension; // 是否可以中断
int nUnstartedThreads = 0; // 还未启动的线程
int nthreads; // ThreadGroup中线程数⽬
Thread threads[]; // ThreadGroup中的线程
int ngroups; // 线程组数⽬
ThreadGroup groups[]; // 线程组数组
}
构造函数：
// 私有构造函数
private ThreadGroup() {
this.name = "system";
this.maxPriority = Thread.MAX_PRIORITY;
this.parent = null;
}
// 默认是以当前ThreadGroup传⼊作为parent ThreadGroup，新线程组的⽗线程组是⽬前正在运⾏线
public ThreadGroup(String name) {
this(Thread.currentThread().getThreadGroup(), name);
}
// 构造函数
public ThreadGroup(ThreadGroup parent, String name) {
this(checkParentAccess(parent), parent, name);
}
// 私有构造函数，主要的构造函数
private ThreadGroup(Void unused, ThreadGroup parent, String name) {
this.name = name;
this.maxPriority = parent.maxPriority;
this.daemon = parent.daemon;
this.vmAllowSuspension = parent.vmAllowSuspension;
this.parent = parent;
parent.add(this);
}
第三个构造函数⾥调⽤了 checkParentAccess ⽅法，这⾥看看这个⽅法的源码：
// 检查parent ThreadGroup
private static Void checkParentAccess(ThreadGroup parent) {
parent.checkAccess();
return null;
}
// 判断当前运⾏的线程是否具有修改线程组的权限
public final void checkAccess() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkAccess(this);
}
}
知识点
这⾥涉及到 SecurityManager 这个类，它是Java的安全管理器，它允许应⽤
程序在执⾏⼀个可能不安全或敏感的操作前确定该操作是什么，以及是否是
在允许执⾏该操作的安全上下⽂中执⾏它。应⽤程序可以允许或不允许该操
作。
⽐如引⼊了第三⽅类库，但是并不能保证它的安全性。
其实Thread类也有⼀个checkAccess()⽅法，不过是⽤来当前运⾏的线程是
否有权限修改被调⽤的这个线程实例。（Determines if the currently running
thread has permission to modify this thread.）
总结来说，线程组是⼀个树状的结构，每个线程组下⾯可以有多个线程或者线程
组。线程组可以起到统⼀控制线程的优先级和检查线程的权限的作⽤。
ThreadLocal
多线程访问同一个共享变量时特别容易出现并发问题，特别是在多个线程需要对一个共享变量写入时。为了保证线程安全，一般使用者在访问共享变量时需要进行适当的同步。同步的措施是加锁，这就需要使用者对锁有一定的了解。
问题：有没有一种方式可以做到，当创建一个变量后，每个线程对其进行访问的时候访问的是自己的变量？
ThreadLocal可以做这个事情，它提供了线程本地变量，也就是如果你创建了一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个本地副本。当多个线程操作这个变量时，实际操作的是自己本地内存里面的变量，从而避免了线程安全问题。
知识点
如果开发者希望将类的某个静态变量（UserID或者transaction ID ）与线程状态关联，则可以考虑使用ThreadLocal。最常见的ThreadLocal使用场景为用来解决数据库连接、Session管理等，数据库连接和Session管理涉及多个复杂对象的初始化和关闭，如果在每个线程中声明一些私有变量来进行操作，那这个线程就变得不那么轻量了，需要频繁的创建和关闭连接。
255
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
