【Java】线程学习笔记

1.线程的生命周期
（1）新建状态：当线程对象创建后即进入了新建态；
（2）可运行状态（就绪态）：当调用线程的start()方法，线程即进入就绪状态，此时只是说明线程已经做好了准备，随时等待CPU调用执行，并不是说执行了start方法此线程就会立即执行；
（3）运行状态：当CPU调用处于就绪状态的线程时，此时线程才是真正的执行，即进入运行状态（也就是说：就绪状态是线程进入到运行状态的唯一入口，线程要想进入运行状态就必须首先处于就绪状态）;
（4）阻塞状态：处于运行状态的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时线程进入阻塞状态，直到其再次进入到就绪状态才有可能被CPU调用执行进入到运行状态；

根据阻塞产生的原因不同，阻塞状态又可以分为三种：
a.等待式阻塞 :运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；
b.同步式阻塞 :线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态;
c.其他阻塞 :通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态.
（5）终止状态：线程执行结束，或因为异常而退出了run（）方法，该线程结束生命周期。
2.线程让步：
Thread.yield（）：暂停当前正在执行的线程，并执行其他线程。
让步实例

class PF extends Thread{

    PF(){
        super.setName("让步线程");
    }
    @Override
    public void run() {
        while(true){
            Thread.yield();//当前线程让步，只让一次
            System.out.println(this.getName());
        }
    }
}

class PF1 implements Runnable{

    @Override
    public void run() {
        while(true){
            System.out.println(Thread.currentThread().getName());
        }
    }
}
public class 让步线程 {
    public static void main(String[] args) {
        PF p = new PF();
        p.start();
        PF1 pm = new PF1();
        Thread p1 = new Thread(pm);
        p1.start();

    }
}

由于让步线程执行的机会少，所以大多时候都是另一个线程被执行

3.线程合并

class GH implements Runnable {
    @Override
    public void run() {
        for(int i = 0;i < 10;i++){
            System.out.println("子线程-1");
        }
    }
}

public class 线程合并 {
    public static void main(String[] args){
       Thread t = new Thread(new GH());
       t.start();
//        try {
//            t.join();//主线程等t线程执行完才开始执行
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        //主线程
        for(int i = 0;i < 10;i++){
            System.out.println("主线程-0");
        }
    }
}

如图：当没有加join（）方法的时候，程序中主线程与子线程是交替执行的;

public class 线程合并 {
    public static void main(String[] args)throws Exception{
       Thread t = new Thread(new GH());
       t.start();
       t.join();//主线程等t线程执行完才开始执行

        //主线程
        for(int i = 0;i < 20;i++){
            System.out.println("主线程-0");
        }
    }
}

加了join（）方法之后，主线程会等待子线程执行完在执行；
由此可见join（）方法是，join（）是一个同步方法，主线程调用了子线程的join（）方法，相当于调用了子线程的wait（）方法，只有当子线程执行完或达到等待时间的时候，主线程才会执行。
4.线程优先级
线程优先级高的执行次数会相对多一些，优先级低的执行次数相对比较少；
线程优先级最大是10，最小是1，默认是5.

class yh implements Runnable{

    @Override
    public void run() {
        while(true){
            System.out.println(Thread.currentThread().getName());
        }
    }
}

public class 线程优先级 {
    public static void main(String[] args) {
        Thread h1 = new Thread(new yh(), "线程1");
        Thread h2 = new Thread(new yh(), "线程2");
        Thread h3 = new Thread(new yh(), "线程3");
        h1.setPriority(Thread.MIN_PRIORITY);
        h2.setPriority(Thread.MAX_PRIORITY);
        h3.setPriority(Thread.MIN_PRIORITY);
        h1.start();
        h2.start();
        h3.start();
    }
}

这样设置，线程2的执行次数会相对多一些

5.线程守护

class GH implements Runnable{

    @Override
    public void run() {
        Thread m2 = new Thread(new GH(),"DDD");
        m2.setDaemon(true);
        m2.start();
        System.out.println(Thread.currentThread().getName());

    }
}

public class 守护线程 {
    public static void main(String[] args) {
        Thread m1 = new Thread(new GH());
        m1.setDaemon(true);//设置守护线程，谁启动它就守护谁，为true就执行
        m1.start();

        for(int i = 0; i < 1000;i++){
            System.out.println(Thread.currentThread().getName());
        }
    }
}

可见当主线程执行完之后，子线程并没有结束（原因：主线程启动其他线程以后，其他线程没有执行完，即使是其主线程执行完了，它也会等其他线程执行完才结束）
所以可以设置一个守护线程，当主线程结束的时候，就不再执行。
例如：

public class 守护线程 {
    public static void main(String[] args) {
        Thread r = new Thread(new th());
        r.setDaemon(true);//设置守护线程，谁启动它就守护谁
        r.start();
        for(int i = 0; i < 100;i++){
            System.out.println(Thread.currentThread().getName());
        }
    }
}

6.线程中断
线程的thread.interrupt()方法是中断线程，将会设置该线程的中断状态位，即设置为true，中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步，就取决于这个程序本身。

class nh extends Thread{
    public void run(){
        while(true){
            System.out.println(this.isInterrupted());
            if(this.isInterrupted()){
                break;
            }
            System.out.println(Thread.currentThread().getName());
        }
    }
}

public class 中断 {
    public static void main(String[] args) {
        nh d = new nh();
        d.start();
        long ti = System.currentTimeMillis();
        while(System.currentTimeMillis() < ti + 100);
        d.interrupt();
    }
}