Java Thread线程详解_线程阻塞了会报错出来吗-优快云博客

本文链接：https://blog.youkuaiyun.com/zhuxingchong/article/details/105798241

本文详细介绍了Java中的线程概念，包括线程的生命周期（新建、就绪、运行、阻塞和死亡状态）、终止线程的4种方式、sleep与wait的区别、start与run的差异、后台线程、ExecutorService与Callable/Future有返回值线程、线程同步及线程通信。通过深入理解这些概念，有助于提升Java多线程编程能力。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

七、ExecutorServiceǃCallable、Future有返回值线程

八、线程同步

九、线程通信

一、介绍

线程：线程是CPU调度的基本单位，也就是说在一个进程中可以有多个并发程序执行流，线程拓展了进程的概念，使得任务的执行得到更加的细分。线程是进程的执行单元，但是线程不是分配系统资源的单位，它们共享所在进程的资源，包括共享内存，公有数据，全局变量，进程文件描述符，进程处理器，进程代码段，进程用户ID等等。
线程独立拥有自己的线程ID，堆栈，程序计数器，局部变量，寄存器组值，优先级，信号屏蔽码，错误返回码等等，线程是独立运行的，其执行是抢占式的。线程共享进程资源，线程之间的通信要进程之间的通信来得容易得多。此外，线程的创建和销毁的开销也远远小于进程的系统开销。
Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。

public class Thread implements Runnable {
    /* Make sure registerNatives is the first thing <clinit> does. */

    /**
     * The synchronization object responsible for this thread's join/sleep/park operations.
     */
    private final Object lock = new Object();

    private volatile long nativePeer;

    boolean started = false;

    private volatile String name;

    private int         priority;
    private Thread      threadQ;
    private long        eetop;

    /* Whether or not to single_step this thread. */
    private boolean     single_step;

    /* Whether or not the thread is a daemon thread. */
    private boolean     daemon = false;

    /* JVM state */
    private boolean     stillborn = false;

    /* What will be run. */
    private Runnable target;

    /* The group of this thread */
    private ThreadGroup group;

    /* The context ClassLoader for this thread */
    private ClassLoader contextClassLoader;

    /* The inherited AccessControlContext of this thread */
    private AccessControlContext inheritedAccessControlContext;

    /* For autonumbering anonymous threads. */
    private static int threadInitNumber;
    private static synchronized int nextThreadNum() {
        return threadInitNumber++;
    }

    /* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;

    /*
     * InheritableThreadLocal values pertaining to this thread. This map is
     * maintained by the InheritableThreadLocal class.
     */
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

    /*
     * The requested stack size for this thread, or 0 if the creator did
     * not specify a stack size.  It is up to the VM to do whatever it
     * likes with this number; some VMs will ignore it.
     */
    private long stackSize;

    /*
     * JVM-private state that persists after native thread termination.
     */
    private long nativeParkEventPointer;

    /*
     * Thread ID
     */
    private long tid;

    /* For generating thread ID */
    private static long threadSeqNumber;

    /* Java thread status for tools,
     * initialized to indicate thread 'not yet started'
     */

    private volatile int threadStatus = 0;


    private static synchronized long nextThreadID() {
        return ++threadSeqNumber;
    }

    /**
     * The argument supplied to the current call to
     * java.util.concurrent.locks.LockSupport.park.
     * Set by (private) java.util.concurrent.locks.LockSupport.setBlocker
     * Accessed using java.util.concurrent.locks.LockSupport.getBlocker
     */
    volatile Object parkBlocker;

    /* The object in which this thread is blocked in an interruptible I/O
     * operation, if any.  The blocker's interrupt method should be invoked
     * after setting this thread's interrupt status.
     */
    private volatile Interruptible blocker;
    private final Object blockerLock = new Object();
.
.
.}

自定义线程

public class MyThread extends Thread {    
 public void run() {      
    System.out.println("MyThread.run()");     
    }   
}   
MyThread myThread1 = new MyThread();   
myThread1.start(); 


如果自己的类已经extends另一个类，就无法直接extends Thread，此时，可以实现一个 Runnable接口。 public class MyThread extends OtherClass implements Runnable {     
    public void run() {      
    System.out.println("MyThread.run()");     
    }   
} 


//启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例： 
MyThread myThread = new MyThread();   
Thread thread = new Thread(myThread);   
thread.start();   //事实上，当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用 target.run() 

public void run() {     
    if (target != null) {      
        target.run();     
    }   
}

二、线程生命周期（状态）

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，它要经过新建(New)、就绪（Runnable）、运行（Running）、阻塞 (Blocked)和死亡(Dead)5种状态。尤其是当线程启动以后，它不可能一直"霸占"着CPU独自运行，所以CPU需要在多条线程之间切换，于是线程状态也会多次在运行、阻塞之间切换

2.1、新建状态(NEW)：

当程序使用new关键字创建了一个线程之后，该线程就处于新建状态，此时仅由JVM为其分配内存，并初始化其成员变量的值

2.2、就绪状态(RUNNABLE)：

如果处于就绪状态的线程获得了CPU，开始执行run()方法的线程执行体，则该线程处于运行状态

2.3、阻塞状态(BLOCKED)：

阻塞状态是指线程因为某种原因放弃了cpu 使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得cpu timeslice 转到运行(running)状态。阻塞的情况分三种

等待阻塞（o.wait->等待队列）：

运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue) 中。

同步阻塞（lock->锁池）：

运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。

其他阻塞（sleep/join）:

运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时， JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O 处理完毕时，线程重新转入可运行(runnable)状态。

2.4、线程死亡（DEAD）：

线程会以下面三种方式结束，结束后就是死亡状态。

正常结束：run()或call()方法执行完成，线程正常结束
异常结束：线程抛出一个未捕获的Exception或Error
调用stop：直接调用该线程的stop()方法来结束该线程—该方法通常容易导致死锁，不推荐使用

三、终止线程4种方式：

正常运行结束

程序运行结束，线程自动结束

程序使用标志主动退出线程

一般 run()方法执行完，线程就会正常结束，然而，常常有些线程是伺服线程。它们需要长时间的运行，只有在外部某些条件满足的情况下，才能关闭这些线程。使用一个变量来控制循环，例如：直接的方法就是设一个boolean类型的标志，并通过设置这个标志为true或false来控制while 循环是否退出，代码示例

public class ThreadSafe extends Thread { 
    public volatile boolean exit = false;  
        public void run() {  
        while (!exit){ 
            //do something 
        } 
    }  
}

定义了一个退出标志exit，当exit为true时，while循环退出，exit的默认值为false.在定义exit 时，使用了一个 Java 关键字 volatile，这个关键字的目的是使 exit 同步，也就是说在同一时刻只能由一个线程来修改exit的值。

Interrupt方法结束

使用interrupt()方法来中断线程有两种情况：

线程处于阻塞状态：如使用了 sleep,同步锁的 wait,socket 中的 receiver,accept 等方法时，会使线程处于阻塞状态。当调用线程的 interrupt()方法时，会抛出 InterruptException 异常。阻塞中的那个方法抛出这个异常，通过代码捕获该异常，然后 break 跳出循环状态，从而让我们有机会结束这个线程的执行。通常很多人认为只要调用 interrupt 方法线程就会结束，实际上是错的，一定要先捕获InterruptedException异常之后通过break来跳出循环，才能正常结束run方法。
线程未处于阻塞状态：使用isInterrupted()判断线程的中断标志来退出循环。当使用 interrupt()方法时，中断标志就会置true，和使用自定义的标志来控制循环是一样的道理。

public class ThreadSafe extends Thread {     
    public void run() {          
    while (!isInterrupted()){ //非阻塞过程中通过判断中断标志来退出             
        try{ 
                Thread.sleep(5*1000);//阻塞过程捕获中断异常来退出 
            }catch(InterruptedException e){ 
                e.printStackTrace(); 
                break;//捕获到异常之后，执行break跳出循环 
            } 
        } 
    }  
}

stop方法终止线程：

程序中可以直接使用thread.stop()来强行终止线程，但是stop方法是很危险的，就象突然关闭计算机电源，而不是按正常程序关机一样，可能会产生不可预料的结果，不安全主要是： thread.stop()调用之后，创建子线程的线程就会抛出 ThreadDeatherror 的错误，并且会释放子线程所持有的所有锁。一般任何进行加锁的代码块，都是为了保护数据的一致性，如果在调用 thread.stop()后导致了该线程所持有的所有锁的突然释放(不可控制)，那么被保护数据就有可能呈现不一致性，其他线程在使用这些被破坏的数据时，有可能导致一些很奇怪的应用程序错误。因此，并不推荐使用stop方法来终止线程。

四、sleep与wait区别

1. 对于sleep()方法，我们首先要知道该方法是属于Thread类中的。而wait()方法，则是属于 Object类中的。
2. sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。

3. 在调用sleep()方法的过程中，线程不会释放对象锁。

4. 而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。

五、start与run区别

1. start（）方法来启动线程，真正实现了多线程运行。这时无需等待 run 方法体代码执行完毕，可以直接继续执行下面的代码。 2. 通过调用 Thread 类的 start()方法来启动一个线程，这时此线程是处于就绪状态，并没有运行。

3. 方法 run()称为线程体，它包含了要执行的这个线程的内容，线程就进入了运行状态，开始运行run函数当中的代码。 Run方法运行结束，此线程终止。然后CPU再调度其它线程。

六、java后台线程：

1. 定义：守护线程--也称“服务线程”，他是后台线程，它有一个特性，即为用户线程提供公共服务，在没有用户线程可服务时会自动离开。

2. 优先级：守护线程的优先级比较低，用于为系统中的其它对象和线程提供服务。

3. 设置：通过 setDaemon(true)来设置线程为“守护线程”；将一个用户线程设置为守护线程的方式是在线程对象创建之前用线程对象的setDaemon方法。

4. 在Daemon线程中产生的新线程也是Daemon的。

5. 线程则是 JVM 级别的，以 Tomcat 为例，如果你在 Web 应用中启动一个线程，这个线程的生命周期并不会和 Web 应用程序保持同步。也就是说，即使你停止了 Web 应用，这个线程依旧是活跃的。

6. example: 垃圾回收线程就是一个经典的守护线程，当我们的程序中不再有任何运行的Thread, 程序就不会再产生垃圾，垃圾回收器也就无事可做，所以当垃圾回收线程是 JVM 上仅剩的线程时，垃圾回收线程会自动离开。它始终在低级别的状态中运行，用于实时监控和管理系统中的可回收资源。

7. 生命周期：守护进程（Daemon）是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。也就是说守护线程不依赖于终端，但是依赖于系统，与系统“同生共死”。当 JVM 中所有的线程都是守护线程的时候，JVM 就可以退出了；如果还有一个或以上的非守护线程则JVM不会退出。

8.yield()：线程让步，也是Thread的静态方法，使得正在执行的线程暂停，但不会阻塞线程，只是交出CPU的控制权，将线程转为就绪状态，让系统调度器重新调度一次。当某个线程调用yield方法暂停后，只有优先级与当前线程相同，或者优先级比当前线程更高的线程才有可能获得执行机会。

9.改变线程优先级：setPriority(int newPriority),高优先级的线程能获得更多的执行机会。

七、ExecutorServiceǃCallable<Class>、Future有返回值线程

有返回值的任务必须实现Callable接口，类似的，无返回值的任务必须Runnable接口。执行 Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了，再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。

//创建一个线程池    
ExecutorService pool = Executors.newFixedThreadPool(taskSize);    
// 创建多个有返回值的任务    
List<Future> list = new ArrayList<Future>();    
for (int i = 0; i < taskSize; i++) {    
    Callable c = new MyCallable(i + " ");    
    // 执行任务并获取Future对象    
    Future f = pool.submit(c);     
    list.add(f);    
}    

// 关闭线程池    
pool.shutdown();     
// 获取所有并发任务的运行结果    
for (Future f : list) {    
    // 从Future对象上获取任务的返回值，并输出到控制台    
    System.out.println("res：" + f.get().toString());    
}

八、线程同步

线程的同步的意义在于线程安全，也就是说有多个线程并发访问同一个对象，而线程调度的不确定性可能带来潜在的安全问题。
同步监视器：java多线程引入同步监视器来解决同步问题，任何时刻只能有一个线程获得对同步监视器的锁定，当同步代码块执行完成后，该线程会释放对同步监视器的锁定。java允许任何对象作为同步监视器，通常我们使用可能被并发访问的共享资源作为同步监视器。
同步代码块：显式指定同步监视器。

public class MyThread extends Thread {
	private Account account;

	
	public MyThread(String name,Account account,double drawaccount) {
		super(name)；
		this.account = account;
	}
	
	public void run() {
		synchronized(account) {
			if(account.getBlance()>=drawaccount) {
				System.out.println(getName());
				try {
					Thread.sleep(1);
				}catch(InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

同步方法：隐式指定同步监视器，使用synchronized关键字来修饰某个方法，此时该方法（非static方法）无需显式指定同步监视器，同步监视器默认为this，也就是调用该方法的对象。

	public synchronized void draw(double amount) {
		……
	}

同步监视器的释放：线程会在以下几种情况下释放同步监视器的锁定。
1. 当前线程的同步方法，同步代码块执行结束或者在执行中遇到break，return等终止了代码块的执行
2. 同步代码块或者方法中出现未处理的Error或者Exception，导致异常结束
3. **当前线程执行同步代码块或者同步方法时，程序中执行了同步监视器的wait()方法，wait是object的方法，范围是该object实例所在的线程
同步锁：lock，更加强大的线程同步机制，通过显式定义锁对象来实现同步，也就是Lock对象，线程在访问共享资源之前，需要先获得锁对象。线程安全控制中比较常用的是ReetrantLock可重入锁。一个线程可以对已经加锁的ReetrantLock再度加锁。

class TestClass{
		private final ReentrantLock lock = new ReentrantLock();
		
		//需要定义线程安全的方法
		public void foo() {
			lock.lock();//加锁
			try {
				// 需要保证线程安全的代码
			}
			finally {
				lock.unlock();//使用finally块保证释放锁
			}
		}
	}

死锁的问题：
产生死锁的四个必要条件：
（1）互斥条件：一个资源每次只能被一个进程使用。
（2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3）不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
（4）循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

在系统中已经出现死锁后，应该及时检测到死锁的发生，并采取适当的措施来解除死锁。目前处理死锁的方法可归结为以下四种：
1. 预防死锁：这是一种较简单和直观的事先预防的方法。方法是通过设置某些限制条件，去破坏产生死锁的四个必要条件中的一个或者几个，来预防发生死锁。预防死锁是一种较易实现的方法，已被广泛使用。但是由于所施加的限制条件往往太严格，可能会导致系统资源利用率和系统吞吐量降低。
2. 避免死锁：该方法同样是属于事先预防的策略，但它并不须事先采取各种限制措施去破坏产生死锁的的四个必要条件，而是在资源的动态分配过程中，用某种方法去防止系统进入不安全状态，从而避免发生死锁。
3. 检测死锁：这种方法并不须事先采取任何限制性措施，也不必检查系统是否已经进入不安全区，此方法允许系统在运行过程中发生死锁。但可通过系统所设置的检测机构，及时地检测出死锁的发生，并精确地确定与死锁有关的进程和资源，然后采取适当措施，从系统中将已发生的死锁清除掉。
4. 解除死锁：这是与检测死锁相配套的一种措施。当检测到系统中已发生死锁时，须将进程从死锁状态中解脱出来。常用的实施方法是撤销或挂起一些进程，以便回收一些资源，再将这些资源分配给已处于阻塞状态的进程，使之转为就绪状态，以继续运行。死锁的检测和解除措施，有可能使系统获得较好的资源利用率和吞吐量，但在实现上难度也最大。
java中应该避免死锁的出现。

九、线程通信

Object类提供的wait()，notify(),notifyAll()三个方法，由同步监视器来调用，对于同步方法，其同步监视器是默认实例this，可以再同步方法中直接调用这三个方法。
1. wait(): 当前线程等待或者等待若干ms，当前线程自动释放同步监视器，线程进入等待状态（阻塞），直到其他线程调用了该同步监视器的notify()或者notifyAll方法。
2. notify():唤醒在同步监视器上等待的单个线程，若有多个线程等待，则任意选择其中一个。
3. notifyAll():唤醒在此同步监视器上等待的所有线程。
使用Condition控制线程通信：使用Lock对象来保证同步问题时，我们可以使用Condition类来释放Lock以及唤醒其他等待线程。

private final Lock lock = new ReentrantLock();
	// Condition实例绑定在一个Lock对象上
	private final Condition cond = lock.newCondition();
	
	public void Draw(double drawamount) {
		lock.lock();
		try {
			if(!flag)
				cond.await();//导致当前线程等待
			else {
				// ...
				cond.signalAll();// 唤醒其他线程
			}
		}catch(InterruptedException e) {
			e.printStackTrace();
		}
		finally {
			lock.unlock();
		}
	}