关于多线程的疑惑。

Question

最近在学多线程，很多疑惑：
1：notify:
加入有200个线程那么notify是随机唤醒一个还是？
2：notyfyALL:
同样200个线程处于wait,唤醒所有只的是除了自己以外的其他全部吗？
3：wait:
当前线程调用wait后之后后面的代码不执行？被唤醒后是从wait后执行还是重新开始之前的执行同步块，
4：synchronized跟run：如：
main{
ThreadB b=new ThreadB();
    b.start();
    System.out.println("b is start....");
    synchronized(this){...}}
class ThreadB extends Thread{.
run{...}..
}这样，他是先执行那个，貌似不确定的感觉，是主线程main先开始还是子线程b先开始，那个先执行，如果不确定的话又是为啥不确定的；例子：
之前在别人那里看到的：
/**
 * 
 */public class TT implements Runnable {
int b = 100;
public synchronized void m1() throws Exception {
b = 1000;
Thread.sleep(10);
System.out.println("b = " + b);
} public synchronized void m2() throws Exception {
Thread.sleep(4500);
b = 2000;
System.out.println(b);
Thread.sleep(500);
} public void run() {
try {
m1();
} catch (Exception e) {
e.printStackTrace();
} } public static void main(String[] args) throws Exception { TT tt = new TT();
Thread t = new Thread(tt);
t.start();
tt.m2();
System.out.println("a =" + tt.b); }}这个是那个为啥是tt.m2();先执行，跟着System.out.println("a =" + tt.b);其次才是t.start();    tt.m2();这个先执行后我把休眠时间设置再大也是System.out.println("a =" + tt.b);在t.start();之前先输出，这又是为啥？多线程

Answer 1

还有一个问题，有时候明明main方法已经结束了，后面还有输出是为啥？

Answer 2

最近在学多线程，很多疑惑：
1：notify:
加入有200个线程那么notify是随机唤醒一个还是？
随机一个。2：notyfyALL:
同样200个线程处于wait,唤醒所有只的是除了自己以外的其他全部吗？
恩。3：wait:
当前线程调用wait后之后后面的代码不执行？被唤醒后是从wait后执行还是重新开始之前的执行同步块，
wait后执行。4：synchronized跟run：如：
main{
ThreadB b=new ThreadB();
    b.start();
    System.out.println("b is start....");
    synchronized(this){...}}
class ThreadB extends Thread{.
run{...}..
}这样，他是先执行那个，貌似不确定的感觉，是主线程main先开始还是子线程b先开始，那个先执行，如果不确定的话又是为啥不确定的；主线程先开始，无论如何都是主线程先开始，因为主线程不开始，其他线程就没办法开始。貌似是synchronized没有什么关系。例子：
之前在别人那里看到的：
/**
 * 
 */public class TT implements Runnable {
int b = 100;
public synchronized void m1() throws Exception {
b = 1000;
Thread.sleep(10);
System.out.println("b = " + b);
}public synchronized void m2() throws Exception {
Thread.sleep(4500);
b = 2000;
System.out.println(b);
Thread.sleep(500);
}public void run() {
try {
m1();
} catch (Exception e) {
e.printStackTrace();
}}public static void main(String[] args) throws Exception {TT tt = new TT();
Thread t = new Thread(tt);
t.start();
tt.m2();
System.out.println("a =" + tt.b);}}
？？？？
main方法体属于一个线程，其他的线程也是线程。必须所有具有输出的线程停止之后，程序才会停止输出。

Answer 3

主线程先开始还是先执行？
“main方法体属于一个线程，其他的线程也是线程。必须所有具有输出的线程停止之后，程序才会停止输出”：加入main线程里面有2个线程，那意思是说main线程可以在其他线程之前先停，之后的线程也可以输出，可以不在main现在之前先停止？这这样吗？

Answer 4

首先，多线程中有两个术语你必须知道，一：线程 二：任务，所谓线程就是独立拥有一个堆栈（暂且先这么理解），而任务是静态的，就是你的代码，在内存中就是一行一行的0和1.每个线程在执行任务的时候拥有自己的堆栈，任务和线程是不相关的。
对于你的第一个问题，首先，Java中线程的状态你必须知道，某个线程使用wait后，释放对象锁，然后这个线程进入wait状态，对于notify，官方文档说的是随机唤醒处于wait中的一个线程，而notifyAll唤醒所有处于wait状态的线程。然后进入block状态，这个状态不是由于I/O造成的block状态，而是由于对象锁，然后这些被唤醒的线程和其他线程一起竞争这个锁，都是公平待遇。待续

Answer 5

然后，使用wait是block线程，开始说了，线程是一个堆栈（暂且还是这么说），然后你执行任务，也就是代码，在block线程的时候会记录执行的位置，就像函数调用一样。所以，如果这个线程有机会竞争到了对象锁，还是从它开始被wait的下一行执行。对于线程调用start后，谁先开始执行，完全取决于操作系统，如果你想深入了解，估计还要点时间，所以，线程执行的先后顺序是不确定的，执行线程的时候，程序是无法进行控制的。这就是为什么会有锁和wait出现。锁是为了解决资源竞争，而wait是为了解决线程合作。待续

Answer 6

主线程先开始还是先执行？
“main方法体属于一个线程，其他的线程也是线程。必须所有具有输出的线程停止之后，程序才会停止输出”：加入main线程里面有2个线程，那意思是说main线程可以在其他线程之前先停，之后的线程也可以输出，可以不在main现在之前先停止？这这样吗？是的。线程之间，彼此是平等的。一般不存在某个线程停止了，其他线程也必须停止的问题。
（当然，人为的原因除外）

Answer 7

这个和java虚拟机和操作系统有关。java虚拟机是多线程的，但是每个java程序运行的时候它都是进程。因为只有进程才能申请到内存，而一个java程序里有很多的线程，这些线程共用这个进程的内存，数据等。而main方法只是其中的一个线程而已，所以一个程序在main方法结束后并不一定就会结束，还有其他的线程在工作，所以main方法结束后还会输出语句那太正常了！

Answer 8

还有就是main方法和main线程是两码事，不要认为main方法就是main线程

Answer 9

关于main方法结束，貌似只是主线程结束，但是如果主线程中启动的其他的线程没有结束，那么这个进程是没有结束的。JVM只有在只有守护（dameon）线程的时候，才会结束虚拟机进程。希望这篇文章对你有帮助：
http://www.lantaozi.com/article/52209f4b6836415678000001

Answer 10

谢谢你了，大体知道点了，但是对于main函数的线程跟子线程，是那个先开始，执行我知道是不确定的；

Answer 11

主线程先开始还是先执行？
“main方法体属于一个线程，其他的线程也是线程。必须所有具有输出的线程停止之后，程序才会停止输出”：加入main线程里面有2个线程，那意思是说main线程可以在其他线程之前先停，之后的线程也可以输出，可以不在main现在之前先停止？这这样吗？是的。线程之间，彼此是平等的。一般不存在某个线程停止了，其他线程也必须停止的问题。
（当然，人为的原因除外）主线程先开始，执行就不一定了?