同時顔の質問の概要

1.スレッドとプロセスは何ですか？

プロセス：独立に、オペレーティングシステムの実行、およびリソース割当の基本単位としての能力。これは、プログラムが実行されていることを示しています。システムは、絶滅のプロセスを実行するために、プログラムは作成からプロセスです実行されています。

スレッド：また、軽量プロセスとして知られている機能のプロセスを完了するためのプロセスの実行よりも小さい単位は、あります。プロセスは、その実行中に複数のスレッドを生成します。

[注]スレッドとプロセスが異なる：複数のスレッドの同じ種類のプロセス共有ヒープおよびメソッド領域リソースをするが、各スレッドはそれ自身の持つプログラムカウンタ、仮想マシン・スタックとネイティブメソッドスタックをので、システムは、スレッドを生成し、又は仕事のためのスレッド間でスイッチングしているとき、負担はプロセスよりもはるかに小さいです。

なぜ、プログラムカウンタは、スタックとは、仮想マシンのスレッドプライベートネイティブメソッドスタックですか？なぜ、ヒープおよびメソッド領域は、それのスレッドで共有されますか？

なぜ、プログラムカウンタは、プライベートで？

プログラムカウンタは2つの機能を次のとおりです。

実行、選択サイクル、例外処理の順序：バイトコードインタプリタプログラムカウンタは、次のようなフロー制御コードを達成するために、順次読み出し命令によって変更されます。

複数のスレッドの場合、現在のスレッドを実行するためのプログラムカウンタの記録位置は、なるようにスレッドがスレッドが最後に実行した場所を知るためにスイッチバックされたとき。

（あなたがネイティブメソッドを実行した場合なお、その後、プログラム・カウンタ・レコードは、プログラムカウンタアドレスの次の命令が記録されたときであるJavaコードの実行のみ、未定義のアドレスです。）

したがって、プログラムカウンタは、主に民間にあるスレッド切り替えが正しく実行位置に戻すことができる後。

VMスタックおよびネイティブメソッドはなぜプライベートでスタック？

VMスタック：各Javaメソッドは、ように情報テーブルを格納するスタックのローカル変数、オペランドスタック、定数プール参照とを実施するための同じ時間枠内に作成されます。呼処理方法の実行が完了するまで、それは、Java仮想マシン内のスタックのスタックフレームを押すとポップの処理に相当します。

ネイティブメソッドがスタック：スタックと仮想マシンが役割と非常によく似て、違いは次のとおりです（つまりバイトコード）は、Java仮想マシンのVMのスタック方法を実行するためのサービス、ネイティブメソッドスタック、仮想マシンのネイティブサービスのメソッドを使用します。HotSpot仮想マシンと組み合わせたJava仮想マシンスタックで。

したがって、順番にスレッドを確実にするために、ローカル変数が他のスレッドにアクセスすることはできません、仮想マシン・スタックおよびスタックネイティブメソッドには、専用スレッドです。

ヒープおよびメソッド領域は、リソースのすべてのスレッドで共有されているなど、：

ヒープは、主に（すべてのオブジェクトがここにメモリを割り当てる）新しく作成されたオブジェクトを格納するために使用されるメモリのプロセスの最大の部分です。

領域を格納するための方法は、主に基づく情報は、コードコンパイラとして、定数、静的変数、リアルタイムデータをロードされているされています。

2.コンテキストスイッチとは何ですか？

　　シングルコアプロセッサは、マルチスレッド・コードの実行をサポートしている場合でも、CPU機構は、各スレッドにCPUタイムスライスを割り当てることによって、これを達成します。時間が非常に短い作品ですので、常に実行スレッドを切り替えることによりCPUは、私たちは複数のスレッドが同時に実行されていると感じます。ので、CPUのタイムスライスは、時間の各スレッドに割り当てられています（タイムスライスは、通常、数十ミリ秒です）

　　これは、タスクのタイムスライス、現在のタスクの実行のタイムスライスを実行するためにCPUサイクルで次のタスク割り当てアルゴリズムに切り替わります。しかし、次の状態が戻ってタスクに切り替えるためになるように、タスクの状態を保存しますスイッチの前に、あなたは、このタスクをロードすることができます。だから、タスクは、ロードプロセスからコンテキストスイッチを保存することです。コンテキストスイッチング速度は、複数のスレッドの実行に影響を及ぼします。

3、同時並列？

　　並行処理は、並列に真の意味で「同時に」とは、タスクの代替の数を指します。

　　実際には、唯一のCPUの場合、マルチスレッドの使用は、実際のシステム環境では平行ではない、システムのみ同時に実行タスクのために、タイムスライスを介して交互に切り替えることができます。実際のパラレルは、複数のCPUを有するシステムで起こり得ます。

4、ライフサイクルとスレッドステータス？（重要！）

唯一のいずれかの状態に以下の6つの異なる状態であってもよいライフサイクルにおける所与の時点で実行中のJavaスレッド：

　　初期状態、遮断状態、状態を実行するには、状態、タイムアウト待ち状態、終了状態を待ちます

スレッドのライフサイクルの一つの状態で固定され、異なる状態の間で切り替えるためのコードの実行とされません。

スレッドは、それがになります作成された後、初期状態、（NEW）を呼び出し start() た後に実行するためにstartメソッドを、スレッドでは、この時間は、 状態を実行することができます（READY）。
CPUタイムスライスにある後の状態を実行中のスレッドを得ることができる動作状態（RUNNING）。
当线程执行 wait()方法之后，线程进入 等待状态(WAITING)，进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态【notify()】。而 超时等待状态(TIME_WAITING)相当于在等待状态的基础上增加了超时限制，【sleep（long millis）/wait（long millis）】，当超时时间到达后 Java 线程将会返回到运行状态。
当线程调用同步方法时，在没有获取到锁的情况下，线程将会进入到阻塞状态(BLOCKED)。
线程在执行 Runnable 的run()方法之后将会进入到 终止状态(TERMINATED)。

5、什么是线程死锁?如何避免死锁?

　　多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。

　　假如线程 A 持有资源 2，线程 B 持有资源 1，他们同时都想申请对方的资源，所以这两个线程就会互相等待而进入死锁状态。

避免死锁的几个常见方法：

避免一个线程同时获取多个锁
避免一个线程在锁内同时占用多个资源，尽量保证每个锁只占用一个资源。
尝试使用定时锁，使用 lock.tryLock(timeout) 来代替使用内部锁机制。
对于数据库锁，加锁和解锁必须在一个数据库连接里，否则会出现解锁失败的情况。

6、sleep() 方法和 wait() 方法区别和共同点?（重要！）

相同点：

　　两者都可以暂停线程的执行，都会让线程进入阻塞状态。

不同点：

sleep()方法没有释放锁，而 wait()方法释放了锁。
sleep()方法属于Thread类的静态方法，作用于当前线程；而wait()方法是Object类的实例方法，作用于对象本身。
执行sleep()方法后，可以通过超时或者调用interrupt()方法interrupt()方法唤醒休眠中的线程；执行wait()方法后，通过调用notify()或notifyAll()方法唤醒等待线程。

7、为什么我们调用 start() 方法时会执行 run() 方法，为什么我们不能直接调用 run() 方法？

　　new 一个 Thread，线程进入初始状态；调用 start()方法，会启动一个线程并使线程进入了就绪状态，当分配到时间片后就可以开始运行了。 start() 会执行线程的相应准备工作，然后自动执行 run() 方法的内容，这是真正的多线程工作。而直接执行 run() 方法，会把 run 方法当成一个 main 线程下的普通方法去执行，并不会在某个线程中执行它，所以这并不是多线程工作。

总结：调用 start 方法可启动线程并使线程进入就绪状态，而 run 方法只是 thread 的一个普通方法调用，还是在主线程里执行。

8、 synchronized 关键字

synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。

synchronized关键字最主要的三种使用方式：修饰实例方法:、修饰静态方法、修饰代码块。

对于普通同步方法，锁是当前实例对象。
对于静态同步方法，锁是当前类的Class对象。
对于同步方法块，锁是synchronized括号里配置的对象。

　　当一个线程试图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁。

synchronized在JVM里是怎么实现的？

　　synchronized 同步语句块的实现使用的是 monitorenter 和 monitorexit 指令，其中 monitorenter 指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。当执行 monitorenter 指令时，线程试图获取锁也就是获取 monitor的持有权。当计数器为0则可以成功获取，获取后将锁计数器设为1也就是加1。相应的在执行 monitorexit 指令后，将锁计数器设为0，表明锁被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另外一个线程释放为止。

(monitor对象存在于每个Java对象的对象头中，synchronized 锁便是通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因)

synchronized用的锁是存在哪里的？

　　synchronized用到的锁是存在Java对象头里的。

9、说说 JDK1.6 之后的synchronized 关键字底层做了哪些优化，可以详细介绍一下这些优化吗

　　JDK1.6 对锁的实现引入了大量的优化，如偏向锁、轻量级锁、自旋锁、适应性自旋锁、锁消除、锁粗化等技术来减少锁操作的开销。

　　锁主要存在四种状态，依次是：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。

　　关于这几种优化的详细信息可以查看这篇文章：https://gitee.com/SnailClimb/JavaGuide/blob/master/docs/java/Multithread/synchronized.md

10、synchronized和ReentrantLock（重入锁）的区别？

两者都是可重进入锁，就是能够支持一个线程对资源的重复加锁。sychnronized关键字隐式的支持重进入，比如一个sychnronized修饰的递归方法，在方法执行时，执行线程在获取了锁之后仍能连续多次地获取该锁。ReentrantLock虽然没能像sychnronized关键字一样隐式的重进入，但是在调用lock()方法时，已经获取到锁的线程，能够再次调用lock()方法获取锁而不被阻塞。
- 线程重复n次获取了锁，随后在第n次释放该锁后，其他线程能够获取到该锁。锁的最终释放要求锁对于获取进行计数自增，计数表示当前锁被重复获取的次数，而锁被释放时，计数自减，当计数等于0时表示锁已经成功被释放。
synchronized 依赖于 JVM 而 ReentrantLock 依赖于 API。ReentrantLock 是 JDK 层面实现的（也就是 API 层面，需要 lock() 和 unlock() 方法配合 try/finally 语句块来完成）
ReentrantLock 比 synchronized 增加了一些高级功能，主要有3点：①等待可中断；②可实现公平锁；③可实现选择性通知（锁可以绑定多个条件）
- ReentrantLock提供了一种能够中断等待锁的线程的机制，也就是说正在等待的线程可以选择放弃等待，改为处理其他事情。通过lock.lockInterruptibly()来实现这个机制。
- ReentrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。（公平锁就是先等待的线程先获得锁）
- synchronized关键字与wait()和notify()/notifyAll()方法相结合可以实现等待/通知机制。ReentrantLock类当然也可以实现，但是需要借助于Condition接口与newCondition() 方法。用ReentrantLock类结合Condition实例可以实现“选择性通知” 。如果执行notifyAll()方法的话就会通知所有处于等待状态的线程这样会造成很大的效率问题，而Condition实例的signalAll()方法只会唤醒注册在该Condition实例中的所有等待线程

11、volatile关键字

　　保证共享变量的“可见性”。可见性的意思是当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。

　　把变量声明为volatile，这就指示 JVM每次使用它都到主存中进行读取。

12、synchronized 关键字和 volatile 关键字的区别

volatile关键字是线程同步的轻量级实现，所以volatile性能比synchronized关键字要好。但是volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块。
多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能会发生阻塞。、
volatile关键字主要用于解决变量在多个线程之间的可见性，而 synchronized关键字解决的是多个线程之间访问资源的同步性。
volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证。

13、使用线程池的好处？

降低资源消耗。通过重复利用已创建的线程，降低线程创建和销毁造成的消耗。
提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。

14、说一说几种常见的线程池即适用场景？

　　可以创建（Executors.newXXX）3种类型的ThreadPoolExecutor：FixedThreadPool、SingleThreadExecutor、CachedThreadPool。

FixedThreadPool：可重用固定线程数的线程池。（适用于负载比较重的服务器）
- FixedThreadPool使用无界队列LinkedBlockingQueue作为线程池的工作队列
- 该线程池中的线程数量始终不变。当有一个新的任务提交时，线程池中若有空闲线程，则立即执行。若没有，则新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务。
SingleThreadExecutor：只会创建一个线程执行任务。（适用于需要保证顺序执行各个任务；并且在任意时间点，没有多线程活动的场景。）
- SingleThreadExecutorl也使用无界队列LinkedBlockingQueue作为工作队列
- 若多余一个任务被提交到该线程池，任务会被保存在一个任务队列中，待线程空闲，按先入先出的顺序执行队列中的任务。
CachedThreadPool：是一个会根据需要调整线程数量的线程池。（大小无界，适用于执行很多的短期异步任务的小程序，或负载较轻的服务器）
- CachedThreadPool使用没有容量的SynchronousQueue作为线程池的工作队列，但CachedThreadPool的maximumPool是无界的。
- 线程池的线程数量不确定，但若有空闲线程可以复用，则会优先使用可复用的线程。若所有线程均在工作，又有新的任务提交，则会创建新的线程处理任务。所有线程在当前任务执行完毕后，将返回线程池进行复用。

ScheduledThreadPool：继承自ThreadPoolExecutor。它主要用来在给定的延迟之后运行任务，或者定期执行任务。使用DelayQueue作为任务队列。

15、线程池都有哪几种工作队列？

ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按FIFO（先进先出）原则对元素进行排序。
LinkedBlockingQueue：是一个基于链表结构的阻塞队列，此队列按FIFO排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列。
SynchronousQueue：是一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于Linked-BlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列。
PriorityBlockingQueue：一个具有优先级的无限阻塞队列。

16、创建线程的几种方式？

有4种方式：继承Thread类、实现Runnable接口、实现Callable接口、使用Executor框架来创建线程池。

（1）通过继承Thread类创建线程

public class MyThread extends Thread {//继承Thread类

　　//重写run方法

　　public void run(){

　　}

}

----------------------------------------------------------------------------------

public class Main {

　　public static void main(String[] args){

　　　　new MyThread().start(); //创建并启动线程

　　}

}

（2）通过实现Runnable接口来创建线程

public class MyThread2 implements Runnable {//实现Runnable接口

　　//重写run方法

　　public void run(){

　　}

}

------------------------------------------------------------------------------------------

public class Main {

　　public static void main(String[] args){

　　　　//创建并启动线程

　　　　MyThread2 myThread=new MyThread2();

　　　　Thread thread=new Thread(myThread);

　　　　thread().start();

　　　　//或者 new Thread(new MyThread2()).start();

　　}

}

不管是继承Thread还是实现Runnable接口，多线程代码都是通过运行Thread的start()方法来运行的。

（3）实现Callable接口来创建线程

　　与实现Runnable接口类似，和Runnable接口不同的是，Callable接口提供了一个call() 方法作为线程执行体，call()方法比run()方法功能要强大：call()方法可以有返回值、call()方法可以声明抛出异常。

public class Main {

　　public static void main(String[] args){

　　　MyThread3 th=new MyThread3();

　　　//使用Lambda表达式创建Callable对象

　　 //使用FutureTask类来包装Callable对象

　　　FutureTask<Integer> future=new FutureTask<Integer>(

　　　　(Callable<Integer>)()->{

　　　　　　return 5;

　　　　}

　　 );

　　　new Thread(task,"有返回值的线程").start();//实质上还是以Callable对象来创建并启动线程

　　 try{

　　　　System.out.println("子线程的返回值："+future.get());//get()方法会阻塞，直到子线程执行结束才返回

　　 }catch(Exception e){

　　　　ex.printStackTrace();

　　　}

　　}

}

（4）使用Executor框架来创建线程池

　　Executors.newXXXX： newFixedThreadPool(int )、newSingleThreadExecutor、newCachedThreadPool、newScheduledThreadPool(int)

　　通过Executors的以上四个静态工厂方法获得 ExecutorService实例，而后可以执行Runnable任务或Callable任务。

Executor执行Runnable任务：

　　通过Executors的以上四个静态工厂方法获得 ExecutorService实例，而后调用该实例的execute（Runnable command）方法即可。一旦Runnable任务传递到execute（）方法，该方法便会自动在一个线程上。

public class TestCachedThreadPool{   
    public static void main(String[] args){   
        ExecutorService executorService = Executors.newCachedThreadPool();    
        for (int i = 0; i < 5; i++){   
            executorService.execute(new TestRunnable());   
            System.out.println("************* a" + i + " *************");   
        }   
        executorService.shutdown();   
    }   
}   
class TestRunnable implements Runnable{  
    //重写run方法 
public void run(){   
        System.out.println(Thread.currentThread().getName() + "线程被调用了。");   
    }

Executor执行Callable任务：

　　当将一个Callable的对象传递给ExecutorService的submit方法，则该call方法自动在一个线程上执行，并且会返回执行结果Future对象。同样，将Runnable的对象传递给ExecutorService的submit方法，则该run方法自动在一个线程上执行，并且会返回执行结果Future对象，但是在该Future对象上调用get方法，将返回null。

public class CallableDemo{   
    public static void main(String[] args){   
        ExecutorService executorService = Executors.newCachedThreadPool();   
        List<Future<String>> resultList = new ArrayList<Future<String>>();   
  
        //创建10个任务并执行   
        for (int i = 0; i < 10; i++){   
            //使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中   
            Future<String> future = executorService.submit(new TaskWithResult(i));   
            //将任务执行结果存储到List中   
            resultList.add(future);   
        }   
  
        //遍历任务的结果   
        for (Future<String> fs : resultList){   
                try{   
                    while(!fs.isDone);//Future返回如果没有完成，则一直循环等待，直到Future返回完成  
                    System.out.println(fs.get());     //打印各个线程（任务）执行的结果   
                }catch(InterruptedException e){   
                    e.printStackTrace();   
                }catch(ExecutionException e){   
                    e.printStackTrace();   
                }finally{   
                    //启动一次顺序关闭，执行以前提交的任务，但不接受新任务  
                    executorService.shutdown();   
                }   
        }   
    }   
}   
class TaskWithResult implements Callable<String>{   
    private int id;   
  
    public TaskWithResult(int id){   
        this.id = id;   
    }   
  
    // 重写call()方法
    public String call() throws Exception {  
        System.out.println("call()方法被自动调用！！！    " + Thread.currentThread().getName());   
        //该返回结果将被Future的get方法得到  
        return "call()方法被自动调用，任务返回的结果是：" + id + "    " + Thread.currentThread().getName();   
    }   
}

实现Runnable接口和Callable接口的区别？

Runnable接口或Callable接口实现类都可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor执行。两者的区别在于 Runnable 接口不会返回结果但是 Callable 接口可以返回结果。

执行execute()方法和submit()方法的区别是什么呢？

1) execute() 方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；

2) submit() 方法用于提交需要返回值的任务。线程池会返回一个Future类型的对象，通过这个Future对象可以判断任务是否执行成功，并且可以通过future的get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用 get（long timeout，TimeUnit unit）方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。

1.スレッドとプロセスは何ですか？

2.コンテキストスイッチとは何ですか？

3、同時並列？

4、ライフサイクルとスレッドステータス？（重要！）

5、什么是线程死锁?如何避免死锁?

6、sleep() 方法和 wait() 方法区别和共同点?（重要！）

7、为什么我们调用 start() 方法时会执行 run() 方法，为什么我们不能直接调用 run() 方法？

8、 synchronized 关键字

9、说说 JDK1.6 之后的synchronized 关键字底层做了哪些优化，可以详细介绍一下这些优化吗

10、synchronized和ReentrantLock（重入锁） 的区别？

11、volatile关键字

12、synchronized 关键字和 volatile 关键字的区别

13、使用线程池的好处？

14、说一说几种常见的线程池即适用场景？

15、线程池都有哪几种工作队列？

16、创建线程的几种方式？

（1）通过继承Thread类创建线程

（2）通过实现Runnable接口来创建线程

（3）实现Callable接口来创建线程

（4）使用Executor框架来创建线程池

Executors.newXXXX： newFixedThreadPool(int )、newSingleThreadExecutor、newCachedThreadPool、newScheduledThreadPool(int)

实现Runnable接口和Callable接口的区别？

执行execute()方法和submit()方法的区别是什么呢？

おすすめ

10、synchronized和ReentrantLock（重入锁）的区别？

　　Executors.newXXXX： newFixedThreadPool(int )、newSingleThreadExecutor、newCachedThreadPool、newScheduledThreadPool(int)