Java并发编程---Java多线程基本概念-优快云博客

本文链接：https://blog.youkuaiyun.com/2501_90472587/article/details/145541044

如果不进行高并发编程，我们就不能够完全最大化的利用这种多核多线程的能力，使用高并发编程，就能提高我们程序的响应能力，比如迅雷，提供了多线程下载，高并发编程可以在我们编程的时候，使我们的程序模块化，异步化，和简单化, 但是在并发编程里面最需要注意的就是安全问题，因为在同一个进程下的线程是共享这个进程的所有资源，很有可能产生线程安全问题和死锁的问题，在linux里或者在windows里，线程开的太多了，会造成内存耗尽，从而造成死机时间片轮转机制也是有代价的，会进行上下文的切换，这个线程在让出cpu的时候，操作系统会把当前的数据状态存到内存或者磁盘里，当再一次轮到这个线程的时候，又把它取出来加载进去，这个就是上下文切换，切换一次上下文需要耗费大约20000个cpu的时间周期，这个也是非常消耗cpu资源的，如果线程过多，会进行大量的上下文切换，这样就很有可能造成一种情况，假如你起了100个线程，用时间片轮转机制所耗费的时间，远远大于你一个一个线程执行的时间，所以多线程要用好，就得考虑的要全面

2. 认识Java里的线程

public class OnlyMain {
public static void main(String[] args) {
//虚拟机线程管理的接口
ThreadMXBean threadMXBean= ManagementFactory.getThreadMXBean();
//获取线程信息
ThreadInfo[] threadInfos=threadMXBean.dumpAllThreads(false,false);
for (ThreadInfo threadInfo:
threadInfos) {
System.out.println(“[”+threadInfo.getThreadId()+“]”+" "+threadInfo.getThreadName());
}
}
}

我们看上面这一串代码，如果我执行这个main方法，他会执行几个线程呢，有兴趣的小伙伴可以把代码跑一遍，去验证一下，没错他会执行6个线程外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传为啥我只执行了一个main方法，为啥会有六个线程在执行呢 1、main就是我们所说的主线程 2、Finalizer

我们在学习Java的时候，Java是一个面向对象的语言，所有类的父类是那个是Object，在Object里有这样一个方法外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传我们一个对象在有资源要回收的时候，会重写这个方法，然后将回收资源的操作，放到这个方法里面执行，这个方法就会由Finalizer这个线程执行，但是有的时候会发现，这个finalize方法不一定会执行，导，有些关于对象的资源就会没有被回收掉，为什么会这样呢？这个锅得Finalizer线程来背了，是因为Finalizer这个线程是一个守护线程，和主线程同生共死，极有可能主线程挂掉了finalize这个方法还没来得及执行，然后Finalizer也挂掉了

2.1 启动线程的两种方式

Java里的程序天生就是多线程的，新启动线程的方法有：

Thread类
实现接口Runnable
实现接口Callable 有返回值

/***

启动线程的几种方式
*/
public class NewThread {
//继承自Thread类
private static class UseThread extends Thread{
@Override
public void run() {
super.run();
System.out.println(“UseThread:我运行了”);
}
}
//实现runnable接口
private static class UseRun implements Runnable{

@Override
public void run() {
System.out.println(“UseRun:我运行了”);
}
}
//实现callable接口，允许有返回值
private static class UseCall implements Callable{
@Override
public String call() throws Exception {
System.out.println(“UseCall:我运行了”);
return “CallResult”;
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
UseThread useThread=new UseThread();
useThread.start();
UseRun useRun=new UseRun();
new Thread(useRun).start();
UseCall useCall=new UseCall();
FutureTask futureTask=new FutureTask<>(useCall);
new Thread(futureTask).start();
System.out.println(futureTask.get());
}
}

Callable和Runnable实现的方法其实可以看做一种方式，因为在启动线程的时候Callable是放到FutureTask里面的，我们去看看FutureTask是什么东西他是个泛型类，实现了RunnableFuture这个泛型接口，RunnableFuture这个接口又继承了Runnable，和Future，所以我们可以把Runnable和Callable看成一种方式，Callable这种方式是怎么拿到返回值的呢？

futureTask.get（）拿到就是返回值，首先我们看一看Future这个接口都有什么方法外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传我们再去看实现它会先判断这个任务执行的状态是否完成，如果没有完成它会进入等待完成这个方法

private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
final long deadline = timed ? System.nanoTime() + nanos : 0L;
WaitNode q = null;
boolean queued = false;
for (;😉 {
if (Thread.interrupted()) {
removeWaiter(q);
throw new InterruptedException();
}

int s = state;
if (s > COMPLETING) {
if (q != null)
q.thread = null;
return s;
}
else if (s == COMPLETING) // cannot time out yet
Thread.yield();
else if (q == null)
q = new WaitNode();
else if (!queued)
queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
q.next = waiters, q);
else if (timed) {
nanos = deadline - System.nanoTime();
if (nanos <= 0L) {
removeWaiter(q);
return state;
}
LockSupport.parkNanos(this, nanos);
}
else
LockSupport.park(this);
}
}

它会一直等待执行完成完成之后它会执行report方法，咱再看report方法外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

然后我们再去看看Run方法

public void run() {
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result);
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}

它会把Call的返回值通过set方法赋值给outcome，get的时候再把outcome返回回去

protected void set(V v) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = v;
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
finishCompletion();
}
}

这样就能拿到Callable的返回值了，在这里我们要区分Thread和Runnable，Thread是唯一一个对操作系统线程的抽象，而Runnable和Callable是对任务的抽象，一定要区分

2.2 线程安全的停止工作

有开始就有结束，怎样才能让Java里的线程安全的停止工作呢stop（）还是isInterrupted（），static 方法interrupted（）？我们要深了解这些方法一般情况下，Thread的run方法执行完毕，或者抛出了异常，这个线程就在执行完毕，自己就停止了，这是一般情况下，但是我们往往因为业务的需求，需要在满足某种条件的时候，去手动停止这个线程，这个时候我们应该怎么办呢？首先我们还是去看代码去看看Thread里有什么方法外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传我们看到了stop（），destroy（），还有suspend（），但是他们都被@Deprecated注解了，JDK就告诉我们这几个方法就不要用线程的挂起函数suspend（），这个线程在执行挂起的时候，线程不会释放资源，比如它在执行的时候拿到一个锁，挂起的时候他不会释放这个锁，这样就很有可能会导致死锁的问题线程的停止函数stop（），这个函数是极其野蛮的，你调用这个函数，他会立马把这个线程干掉，他不会管你这个线程的资源是否正常的释放，比如你在一个线程里写一个文件，写到一半的时候你调用这个方法，造成文件不能正常结束，而且线程里占据操作系统的资源文件句柄啥的没有得到释放 resume是唤起挂起线程的，和suspend配对使用的其实我们在终止线程的时候，有这么几个方法可以用外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传 interrupt是终止线程，interrupted，isInterrupted是获取线程是否终止，interrupt终止线程是一种协作方式不是那种抢占式，话不多说上代码，

public class EndThread {
private static class UseThread extends Thread{
@Override
public void run() {
super.run();
while(true){
System.out.println(“EndThread:emmmmmm”);
}
}
}

public static void main(String[] args) throws InterruptedException {
UseThread useThread=new UseThread();
useThread.start();
Thread.sleep(30);
useThread.interrupt();
}
}

这段代码是在主线程里面新启动一个线程，主线程休眠30ms去调用useThread的interrupt（），结果怎么样，结果useThread根本不鸟你，一直在执行，我们把代码做一下更改

private static class UseThread extends Thread{
@Override
public void run() {
super.run();
// while(true){
System.out.println(“EndThread:”+isInterrupted());
while(!isInterrupted()){
System.out.println(“EndThread:emmmmmm”);
}
System.out.println(“EndThread:”+isInterrupted());
}
}

我们发现它终止了跳出了循环外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传我们发现在Java里Thread的interrupt方法只是将中断信号由false改为了true而已，如果线程中没有对这个信号做任何处理，它是不会终止这个线程的，所以这个 interrupt是协作式的，不是抢占式的细心的同学可能发现了，获取线程是否中断，有两个方法，一个是 Thread的成员方法 isInterrupted，一个是静态方法interrupted，这两个方法有什么区别呢， interrupted在获取这个线程状态的时候，如果这个中断状态是true，他会获取这个状态的同时，把这个状态设置成false 上面的代码，最终的打印结果为true，我们再改一下代码瞧一瞧

private static class UseThread extends Thread{
@Override
public void run() {
super.run();
// while(true){
System.out.println(“EndThread:”+isInterrupted());
// while(!isInterrupted()){
while(!Thread.interrupted()){
System.out.println(“EndThread:emmmmmm”);
}
System.out.println(“EndThread:”+isInterrupted());
}
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

2.3 深入理解Thread的run()和start()

run方法和我们普通类里的成员方法是没什么区别的，start方法我们点进去也没什么东西，start方法最后执行的是native方法stat0，我们可以调用run，话不多说上代码

private static class UseThread extends Thread{
@Override
public void run() {
super.run();
for (;😉{
System.out.println(Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}