一、Java 中的线程状态转换
【注】不是 start 之后就立刻开始执行，只是就绪了(CPU 可能正在运行其他的线程)。只有被 CPU 调度之后，线程才开始执行，当 CPU 分配给的时间片到了，又回到就绪状态，继续排队等候。
二、线程控制的基本方法
isAlive()：判断线程是否还活着。start 之后，终止之前都是活的。
getPriority()：获得线程的优先级数值。
setPriority()：设置线程的优先级数值(线程是有优先级别的)。
Thread.sleep()：将当前线程睡眠指定毫秒数。
join()：调用某线程的该方法，将当前线程与该线程合并，也即等待该线程结束后，再恢复当前线程的运行状态(比如在线程B中调用了线程 A 的 join()，直到线程A执行完毕后，才会继续执行线程B)。
yield()：当前线程让出 CPU，进入就绪状态，等待 CPU 的再次调度。
wait()：当前线程进入对象的 wait pool。
notify()/notifyAll()：唤醒对象的 wait pool 中的一个/所有的等待线程。
三、isAlive()：判定线程是否处于活动状态
//判定线程是否处于活动状态 : --就绪状态 --运行状态 --阻塞状态
public class Demo2 {
public static void main(String[] args) {
new ThreadB().start();
}
}
class ThreadB extends Thread {
@Override
public void run() {
System.out.println("检测线程是否是活动状态");
System.out.println(Thread.currentThread().isAlive());
}
}
四、setPriority()：设置线程的优先级
//设置线程优先级 MAX_PRIORITY：最大为10
// MIN_PRIORITY：最小为1
// DEFAULT_PRIORITY：默认为5
public class Demo4 {
public static void main(String[] args) {
ThreadD td = new ThreadD();
ThreadE te = new ThreadE();
td.start();// 谁先启动，谁抢占资源的概率越大
te.start();
td.setPriority(Thread.MAX_PRIORITY);// 设置优先级为最大，10
te.setPriority(Thread.MIN_PRIORITY);// 设置优先级为最小，1
}
}
class ThreadD extends Thread {
@Override
public void run() {
// 默认优先级为5
// System.out.println(Thread.currentThread().getPriority());
for (int i = 0; i < 10; i++) {
System.out.println("ThreadD j---" + i);
}
}
}
class ThreadE extends Thread {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("ThreadE i---" + i);
}
}
}
ThreadD j---0
ThreadE i---0
ThreadE i---1
ThreadE i---2
ThreadE i---3
ThreadE i---4
ThreadE i---5
ThreadE i---6
ThreadE i---7
ThreadE i---8
ThreadE i---9
ThreadD j---1
ThreadD j---2
ThreadD j---3
ThreadD j---4
ThreadD j---5
ThreadD j---6
ThreadD j---7
ThreadD j---8
ThreadD j---9
五、sleep()：将当前线程睡眠指定毫秒数
可以调用 Thread 的静态方法：
public static void sleep(long millis) throws InterruptedException在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)，此操作受到系统计时器和调度程序精度和准确性的影响，该线程不丢失任何监视器的所属权。InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的中断状态被清除。
由于是静态方法，sleep() 可以由类名直接调用：Thread.sleep(.....);
class TestThread {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start();
try { // 在哪个线程中调用 Sleep，就让哪个线程睡眠
Thread.sleep(8000); // 主线程睡8秒后，打断子线程
} catch (InterruptedException e) {
}
thread.interrupt(); // 打断子线程
}
}
class MyThread extends Thread {
@Override
public void run() {
while(true){
System.out.println("=== "+ new Date()+" ===");
try {
sleep(1000); // 每隔一秒打印一次日期
} catch (InterruptedException e) {
return;
}
}
}
}
=== Tue May 09 11:09:43 CST 2017 ===
=== Tue May 09 11:09:44 CST 2017 ===
=== Tue May 09 11:09:45 CST 2017 ===
=== Tue May 09 11:09:46 CST 2017 ===
=== Tue May 09 11:09:47 CST 2017 ===
=== Tue May 09 11:09:48 CST 2017 ===
=== Tue May 09 11:09:49 CST 2017 ===
=== Tue May 09 11:09:50 CST 2017 ===
子线程每隔一秒打印系统日期，主线程睡眠8秒后，打断子线程，子线程结束。
在本例中，采用一种简单、粗暴、好用的方法中断子线程：
class TestThread {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start();
try { // 在哪个线程中调用 Sleep，就让哪个线程睡眠
Thread.sleep(5000); // 主线程睡8秒后，打断子线程
} catch (InterruptedException e) {
}
thread.flag = false; // 打断子线程
}
}
class MyThread extends Thread {
boolean flag = true;
@Override
public void run() {
while(flag){
System.out.println("=== "+ new Date()+" ===");
try {
sleep(1000); // 每隔一秒打印一次日期
} catch (InterruptedException e) {
}
}
}
}
=== Tue May 09 12:21:24 CST 2017 ===
=== Tue May 09 12:21:25 CST 2017 ===
=== Tue May 09 12:21:26 CST 2017 ===
=== Tue May 09 12:21:27 CST 2017 ===
=== Tue May 09 12:21:28 CST 2017 ===
六、join()：合并某个线程，相当于方法的调用
class TestThread {
public static void main(String[] args) {
MyThread myThread = new MyThread("childThread");
myThread.start();
try {
myThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
for(int i = 1; i <= 4; i++){
System.out.println("I am the mainThread");
}
}
}
class MyThread extends Thread {
public MyThread(String name) {
super(name);
}
@Override
public void run() {
for(int i = 1; i <= 4; i++){
System.out.println("I am " + getName());
try {
sleep(1000);
} catch (InterruptedException e) {
return;
}
}
}
}
I am childThread
I am childThread
I am childThread
I am childThread
I am the mainThread
I am the mainThread
I am the mainThread
I am the mainThread
在A中调用B的join()函数，等B的函数执行完毕，在执行A的函数。
七、yield()：让出 CPU，当前线程进入就绪状态队列等待，给其他线程执行的机会(就让很小的一个时间片段)。
class TestThread {
public static void main(String[] args) {
MyThread my1 = new MyThread("t1");
MyThread my2 = new MyThread("t2");
my1.start();
my2.start();
}
}
class MyThread extends Thread {
public MyThread(String s) {
super(s);
}
@Override
public void run() {
for(int i = 1; i <= 100; i++){
System.out.println(getName()+":"+i);
if(i % 10 == 0) {
Thread.yield(); // 当前线程让出 CPU 一小会儿
}
}
}
}
八、wait()：它会释放掉对象的锁
当前的线程必须拥有当前对象的 monitor，也即 lock，就是锁。线程调用 wait()，释放它对锁的拥有权，使得当前线程必须要等待。然后等待另外的线程调用 notify() 或者 notifyAll()来通知它，这样它才能重新获得锁的拥有权和恢复执行。要确保调用 wait() 的时候拥有锁，即：wait() 的调用必须放在 synchronized 方法或synchronized 块中。
区别：
1️.当线程调用了 wait() 时，它会释放掉对象的锁。
2️.另一个会导致线程暂停的方法：Thread.sleep()，它会导致线程睡眠指定的毫秒数，但线程在睡眠的过程中是不会释放掉对象的锁的。
九、notify()/notifyAll()：唤醒对象的wait pool 中的一个/所有等待线程
notify() 会唤醒一个等待当前对象的锁的线程。如果多个线程在等待，它们中的一个将会选择被唤醒。这种选择是随意的，和具体实现有关(线程等待一个对象的锁是由于调用了 wait() 中的一个)。被唤醒的线程是不能被执行的，需要等到当前线程放弃这个对象的锁。被唤醒的线程将和其他线程以通常的方式进行竞争，来获得对象的锁。也就是说，被唤醒的线程并没有什么优先权，也没有什么劣势，对象的下一个线程还是需要通过一般性的竞争。
notify() 应该是被拥有对象的锁的线程所调用This method should only be called by a thread that is the owner of this object's monitor。换句话说，和 wait() 一样，notify() 调用必须放在 synchronized 方法或synchronized 块中。
十、一个线程变为一个对象的锁的拥有者的三种方法
执行这个对象的 synchronized 实例方法。
执行这个对象的 synchronized 语句块。这个语句块锁的是这个对象。如 synchronized (object)
对于 Class 类的对象，执行那个类的 synchronized、static 方法。
十一、守护线程，必须在它的start()之前进行设置，通过setDaemon()传入true的参数，当程序只有守护线程时，该程序就可以结束运行了。
//守护线程：在线程启动前设置setDaemon(true)
public class Demo6 {
public static void main(String[] args) throws Exception {
ThreadH th = new ThreadH();
th.setDaemon(true);// 让当前线程设置为守护线程
th.start();
for (int i = 0; i < 10; i++) {
Thread.sleep(1000);
System.out.println("主线程。。。" + i);
}
}
}
class ThreadH extends Thread {
int i;
@Override
public void run() {
while (true) {
try {
sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("Hello,---" + ++i);
}
}
}
十二、Thread 类中的 start() 和 run() 的区别
start() 来启动线程，真正实现了多线程运行。
线程类的 start() 可以用来启动线程；该方法会在内部调用 Runnable 接口的 run()，以在单独的线程中执行 run() 中指定的代码。
这时无需等待 run 方法体代码执行完毕，可以直接继续执行下面的代码。通过调用 Thread 类的 start() 来启动一个线程，这时此线程是处于就绪状态，并没有运行。
然后通过此 Thread 类调用 run() 来完成其运行操作的，这里 run() 称为线程体，它包含了要执行的这个线程的内容，run() 运行结束，此线程终止。然后CPU再调度其它线程。
start() 启动线程执行以下任务：
它统计了一个新线程
线程从 New State 移动到 Runnable 状态。
当线程有机会执行时，它的目标 run() 将运行。
run() 当作普通方法的方式调用。程序还是要顺序执行，要等待 run 方法体执行完毕后，才可继续执行下面的代码；程序中只有主线程——这一个线程，其程序执行路径还是只有一条，这样就没有达到写线程的目的。
调用 start() 才可启动线程，而 run() 只是 thread 的一个普通方法调用，还是在主线程里执行。把需要并行处理的代码放在 run() 中，start() 启动线程将自动调用 run() ，这是由JVM的内存机制规定的。并且 run() 必须是 public 访问权限，返回值类型为void。
start() 不能多次调用，否则抛出java.lang.IllegalStateException。
1626
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
