Java多线程基础知识详解

1、线程的定义

​ 线程是序执行流的最小执行单位，是进程中的实际运作单位，是运行中的实际的任务执行者。

2、线程的生命周期

1. 新建状态（New）：当用new操作符创建一个线程时， 例如new Thread®，线程还没有开始运行，此时线程处在新建状态。 当一个线程处于新生状态时，程序还没有开始运行线程中的代码

2. 就绪状态(Runnable)：一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的start()方法。当线程对象调用start()方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。 处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由Java运行时系统的线程调度程序(thread scheduler)来调度的。

3. 当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法。

4. 阻塞状态(Blocked)：所谓阻塞状态是正在运行的线程没有运行结束，暂时让出CPU，这时其他处于就绪状态的线程就可以获得CPU时间，进入运行状态。以下的情况线程会进入阻塞状态。
   (1)等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放**等待队列(waitting queue)**中。调用notify()方法唤醒该线程。
   (2)同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。
   (3)其他阻塞：运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。

5. 死亡状态(Dead)： 有两个原因会导致线程死亡：
   (1)run方法正常退出而自然死亡，
   (2)一个未捕获的异常终止了run方法而使线程猝死。

为了确定线程在当前是否存活着（就是要么是可运行的，要么是被阻塞了），需要使用isAlive方法。如果是可运行或被阻塞，这个方法返回true； 如果线程仍旧是new状态且不是可运行的， 或者线程死亡了，则返回false.

3、等待队列

1. 调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) 代码段内。
2. 与等待队列相关的步骤和图

• 线程1获取对象A的锁，正在使用对象A。

• 线程1调用对象A的wait()方法。

• 线程1释放对象A的锁，并马上进入等待队列。

• 锁池里面的对象争抢对象A的锁。

• 线程5获得对象A的锁，进入synchronized块，使用对象A。

• 线程5调用对象A的notifyAll()方法，唤醒所有线程，所有线程进入锁池。线程5调用对象A的notify()方法，唤醒一个线程，不知道会唤醒谁，被唤醒的那个线程进入锁池。

• notifyAll()方法所在synchronized结束，线程5释放对象A的锁。

• 锁池里面的线程争抢对象锁，但线程1什么时候能抢到就不知道了。原本锁池+第6步被唤醒的线程一起争抢对象锁。

4、创建线程的三种方式

一、继承Thread

（1）定义一个类Thread1继承Thread，并重写run方法。
（2）将要执行的代码写在run方法中。
（3）创建该类的实例，并调用start()方法开启线程。

代码如下：

a. 创建一个线程实现类，定义观察线程的方法

package com.it520.thread;
public class Thread1 extends Thread {
    // 通过构造方法给线程名字赋值
   public Thread1(String name) {
	 super(name);  
   }// 给线程名字赋值 
    // 为了保持计数的一致，数要静态
    static int i = 10;
    // 创建一个静态钥匙
    static Object ob = "lock";//值是任意的
    // 重写run方法，实现运行操作
    @Override
    public void run() {
      while (i > 0) {
        synchronized (ob) {// 这个很重要，必须使用一个锁，
          // 进去的人会把钥匙拿在手上，出来后才把钥匙拿让出来
          if (i > 0) {
            System.out.println(getName() + "线程调用还有" + i + "次");
            i--;
          } else {
            System.out.println("end");
          }
        }
        try {
           sleep(1000);//sleep当前线程，让其他线程能够进来，这个很重要
        } catch (InterruptedException e) {
          e.printStackTrace();
             }
      }
  }
}

b. 创建主方法调用类

package com.it520.thread;
public class ThreadTest {
	public static void main(String[] args) {
		Thread1 thread1 = new Thread1("thread1");
		Thread1 thread2 = new Thread1("thread2");
		Thread1 thread3 = new Thread1("thread3");
		thread1.start();
		thread2.start();
		thread3.start();	
	}
}

c. 运行结果

thread1线程调用还有10次
thread3线程调用还有9次
thread2线程调用还有8次
thread2线程调用还有7次
thread1线程调用还有6次
thread3线程调用还有5次
thread1线程调用还有4次
thread2线程调用还有3次
thread3线程调用还有2次
thread2线程调用还有1次
end

二、实现Runnable接口

（1）定义一个类Thread2实现Runnable接口，并重写run方法。
（2）将要执行的代码写在run方法中。
（3）创建Thread实例，并传入创建好的该类的实例，并用Thread实例调用start()方法开启线程。

代码如下：

a. 创建一个线程实现类，定义观察线程的方法

package com.it520.thread;
public class Thread2 implements Runnable {

	@Override
	public void run() {
		System.out.println("Thread2.run()");
	}
}

b. 创建主方法调用类

package com.it520.thread;
public class ThreadTest2 {	
public static void main(String[] args) {
	Thread2 threadRunnable = new Thread2();//创建ThradRunnable对象实例
	Thread thread = new Thread(threadRunnable);//实例化一个Thread实例，并将传入ThradRunnable对象实例
	thread.start();
}
}

c. 运行结果

Thread2.run()

​

三、使用ExecutorService、Callable、Future实现有返回结果的多线程

ExecutorService、Callable、Future这个对象实际上都是属于Executor框架中的功能类。想要详细了解Executor框架的可以访问http://www.javaeye.com/topic/366591 ，这里面对该框架做了很详细的解释。返回结果的线程是在JDK1.5中引入的新特征，确实很实用，有了这种特征我就不需要再为了得到返回值而大费周折了，而且即便实现了也可能漏洞百出。
可返回值的任务必须实现Callable接口，类似的，无返回值的任务必须Runnable接口。执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了，再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。下面提供了一个完整的有返回结果的多线程测试例子，在JDK1.5下验证过没问题可以直接使用。代码如下：

package com.it520.thread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
 
public class Thread3 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
    	CallableDemo callableDemo = new CallableDemo();
    	FutureTask futureTask = new FutureTask<>(callableDemo); 
    	new Thread(futureTask).start();
    	List<Integer> lists = (List<Integer>)futureTask.get(); //获取返回值
    	for (Integer integer : lists) {
			System.out.print(integer + "  ");
		}
	}
}
 
class CallableDemo implements Callable<List<Integer>>{
	@Override
	public List<Integer> call() throws Exception {
		boolean f = false;
		List<Integer> lists = new ArrayList<>();
		for(int i  = 3 ; i < 100 ; i ++) {
			f = false;
			for(int j = 2; j <= Math.sqrt(i) ; j++) {
				if(i % j == 0) {
					f = true;
					break;
				}
			}
			if(f == false) {
				lists.add(i);
			}
		}
		return lists;
	}	
}

四、继承Thread和实现Runnable接口的区别

两种方式启动方式不同：
Runnable线程类是实例化一个对象o之后，通过多次new Thread（o）.start();启动多个线程，而这几个线程属于一个对象，对象的成员变量是同一个。
Thread线程类启动多个线程需要 new MyThread().start();每个线程启动都对应多个对象，他们的成员变量是独立的。

根据两种启动方式不同文明来分析这两种实现方式的优劣势：

（1）使用Runnable的优势

​ a、java的单继承，当继承了Thread类，则不能继承其他类，而实现Runnable接口可以。
​ b、实现Runnable接口的线程类的多个线程，可以访问同一变量，而Thread则不能。（当然，Thread可以通过将变量设置为静态变量来解决这个问题）

（2）继承Thread的优势

​ a、使用线程的方法方便一些，例如：获取线程的Id（Thread.currentThread().getId()）、线程名（Thread.currentThread().getName()）、线程状态（Thread.currentThread().getState()）等，在前面介绍这种实现方式的代码中getName（）方法就是运用这个来区分正在运行的线程。
​ b、操作同一变量，但是线程调用run方法内容不同时，使用Thread内部类的方式进行，例如生产者、消费者模式。
————————————————
要是对这两种实现方式想深入了解的读者可参考CSDN博主「dreamer_8399」的文章。
原文链接：https://blog.csdn.net/dreamer_8399/article/details/77839648
对线程和线程池想深入了解的读者可参考CSDN博主「weixin_40271838」的文章。
原文链接：https://blog.csdn.net/weixin_40271838/article/details/79998327当然，想对线程池有进一步了解的可以进入我的主页，进行线程池的学习。