（9）Java多线程

我发现这篇关于线程的文章写的很好，在此强烈推见点击打开链接

了解线程之前要了解以下三点：

1、线程是进程的一个实体，线程本身是不会独立存在的！

2、进程是代码在数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，线程则是进程的一个执行路径，一个进程至少有一个线程，一个进程中的多个线程是共享进程资源的。

3、操作系统在分配资源时，把资源分配给了进程，但是CPU资源比较特殊，它是分配到线程的，因为真正占用CPU资源的是线程，所以线程是CPU分配的基本单位。Java中启动启动main函数时就启动了一个JVM的进程，而main函数所在线程中的一个线程，即主线程。

 

1.程序、进程、线程的区别是什么？

程序（Program）：是一个指令的集合。程序不能独立运行，只有被加载到内存中，系统为它分配资源后才能执行。

进程（Process）：如上所述，一个执行中的程序成为进程。

         进程是系统分配资源的独立单位，每个进程占有特定的地址空间。

         程序是进程的静态文本描述，进程是程序在系统内顺序的执行的动态活动。

线程（Thread）：是进程“单一的连续控制流程”。

        线程是CPU调度和分配的基本单位，是比进程更小的能独立运行的基本单位，也被称为轻量级的进程。

        线程不能独立存在，必须依附于某个进程。Java虚拟机允许应用进程并发地执行多个线程。

 

2.Java中通过哪些方式创建多线程类？用代码举例。

（1）自定义线程类继承Thread，重写run方法：

package Thread;

public class MyDefinedThread extends Thread{
	//重写run方法
	public void run() {
		//把线程需要执行的任务写在run方法里面
	}
	public static void main(String[] args) {
		MyDefinedThread mdt = new MyDefinedThread();
		mdt.start(); //启动线程
	}
}

    使用继承方式好处是 run 方法内获取当前线程直接使用 this 就可以，无须使用 Thread.currentThread() 方法，不好的地方是 Java 不支持多继承，如果继承了 Thread 类那么就不能再继承其它类。另外任务与代码没有分离，当多个线程执行一样的任务时候需要多份任务代码，而 实现Runable 接口则没有这个限制。

 

（2）自定义类实现Runnable接口，重写run方法：

package Thread;

public class MyRunnable implements Runnable {
	public static void main(String[] args) {
		MyRunnable mr = new MyRunnable();
		//mr并不是一个线程对象，而是要作为参数传递到Thread的构造方法中，th才是一个线程对象
		Thread th = new Thread(mr);
		th.start();
	}
	@Override
	public void run() {
		//把线程要执行的任务放在run方法里
	}
}

    当创建完 thread 对象后该线程并没有被启动执行，而调用 start 方法后才是真正启动了线程。其实当调用了 start 方法后线程并没有马上执行而是处于就绪状态，这个就绪状态是指该线程已经获取了除 CPU 资源外的其它资源，等获取 CPU 资源后才会真正处于运行状态。当 run 方法执行完毕，该线程就处于终止状态了。

 

（3）如上面代码，两个线程公用一个 task 代码逻辑，需要的话 RunableTask 可以添加参数进行任务区分，另外 RunableTask 可以继承其他类，但是上面两种方法都有一个缺点就是任务没有返回值，下面看最后一种是使用 FutureTask：

package com.review04.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

//创建任务类
public 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 result = futureTask.get(); //等待任务执行完毕，并返回结果
            System.out.println(result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

 

 

 

3.Thread类实现Runnable接口了吗？当调用一个线程对象的start方法后，线程马上进入运行状态吗？

Thread类实现了Runnable接口。

当调用start方法之后，只是进入就绪（可运行）状态，等待分配CPU时间片。一旦得到CPU时间片，即进入运行状态。

 

4.下面的代码实际上有几个线程在运行？

package Thread;

public class MyRunnable implements Runnable {
	public static void main(String[] args) {
		MyRunnable mr = new MyRunnable();
		//mr并不是一个线程对象，而是要作为参数传递到Thread的构造方法中，th才是一个线程对象
		Thread th = new Thread(mr);
		th.start();
	}
	@Override
	public void run() {
		//把线程要执行的任务放在run方法里
	}

}

两个，线程th和main()方法（主线程）。

 

5.说说：sleep、yield、join方法的区别。

    sleep（）：在指定的时间内让线程暂停执行，进入阻塞状态。

         在指定时间到达后进行就绪状态。线程调用sleep()方法时，释放CPU当不释放对象锁（如果持有某个对象的锁的话）。

    join（）：当前线程等待调用此方法的线程执行结束再继续执行。

         如：在main方法中调用t.join，那main方法在此时进入阻塞状态，一直等t线程执行完，main方法在恢复到就绪状态，准备继续执行。

    yield（）：调用该方法的程序先暂停一下，回到就绪状态。所以调用该方法的线程很可能进入就绪状态后马上又被执行。

 

6.wait、notify、notifyAll是在Object类中定义的方法吗？作用分别是什么？

wait()、notify()、notifyAll()不属于Thread类，而是属于Object类，也就是说每个对象都有wait()、notify()、notifyAll()的功能。因为每个对象都有锁，锁是每个对象的基础。而wait()、notify()、notifyAll()都是跟锁有关的方法。

作用：

    wait()：导致当前线程等待，进入阻塞状态，直到其他线程调用此对象的notify()方法或者notifyAll方法。当前线程必须拥有此对象监视器（对象锁）。该线程释放对此监视器的所有权并等待，直到其他线程通过调用notify方法，或者notifyAll方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。

    notify()：唤醒在此对象监视器（对象锁）上等待单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。直到当前线程放弃此对象上的锁定，才能继续执行被唤醒的线程。此方法只应由作为此对象监视器的所有者的线程来调用。

“当前线程必须拥有此对象监视器（对象锁）”与“此方法只应由作为此对象监视器的所有者的线程来调用”说明——wait方法和notify方法必须在同步代码块内执行，即synchronized（obj之内）。

    notifyAll()：唤醒在此对象监视器（对象锁）上等待的所有线程。

 

7.wait方法被调用时，所在线程是否会释放所持有的锁资源？sleep方法呢

     wait：释放CPU，释放锁。

    sleep：释放CPU，不释放锁。

 

8.notify是唤醒所在对象wait pool中的第一个线程吗？

    不是。

    调用notify（）方法导致解除阻塞的线程是从因调用该对象的wait（）方法而阻塞的线程中随机选取的，我们无法预料哪一个线程将会被选择。