《java多线程编程核心技术》第一章 Java多线程技能

1 currentThread()方法

currentThread()方法可返回代码段正在被哪个线程调用的信息。
案例1：

package com.wuk.demo01;

public class MyThread extends Thread{

    public MyThread(){
        //main
        System.out.println("MyThread----"+Thread.currentThread().getName());
    }

    @Override
    public void run() {
        //A
        System.out.println("run-----"+Thread.currentThread().getName());
    }
}

package com.wuk.demo01;

public class MainTest {

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.setName("A");
        myThread.start();
//        myThread.run();
    }
}

结果：

MyThread----main
run-----A

结论：
因为构造方法是被main线程调用的，而run()是被A线程调用的。
案例2：

package com.wuk.demo02;

public class CountOperate extends Thread{

    public CountOperate(){

        System.out.println("CountOperate----开始");
        //thread-0
        System.out.println("CountOperate----this----"+this.getName());
        //main
        System.out.println("CountOperate----currentThread----"+Thread.currentThread().getName());
        System.out.println("CountOperate----结束");
    }

    @Override
    public void run() {

        System.out.println("run----开始");
        //Thread-0
        System.out.println("run----this----"+this.getName());
        //A
        System.out.println("run----currentThread----"+Thread.currentThread().getName());
        System.out.println("run----结束");
    }
}

package com.wuk.demo02;
public class MainTest02 {

    public static void main(String[] args) {
        CountOperate countOperate = new CountOperate();
        Thread t1 = new Thread(countOperate);
        t1.setName("A");
        t1.start();
    }
}

结果：

CountOperate----开始
CountOperate----this----Thread-0
CountOperate----currentThread----main
CountOperate----结束
run----开始
run----this----Thread-0
run----currentThread----A
run----结束

结论：
this：表示的就是当前所在的类的对象。
Thread.currentThread()：表示的就是当前代码正在被哪个线程执行的信息。

2 isAlive()

判断当前线程是否处于活动状态。
活动状态是指线程已经启动尚未终止，当线程处于正在运行或者准备运行的状态，就认为线程是存活的。
案例：

package com.wuk.demo04;

public class CountOperate04 extends Thread{

    public CountOperate04(){

        System.out.println("CountOperate----开始");
        System.out.println("CountOperate----this--name--"+this.getName());
        System.out.println("CountOperate----this--isAlive--"+this.isAlive());
        System.out.println("CountOperate----结束");
    }

    @Override
    public void run() {

        System.out.println("run----开始");
        System.out.println("run---currentThread--Thread--name--"+Thread.currentThread().getName());
        System.out.println("run----currentThread--Thread--isAlive--"+Thread.currentThread().isAlive());
        System.out.println("run----currentThread--this--name--"+this.getName());
        System.out.println("run----currentThread--this--isAlive--"+this.isAlive());
        System.out.println("run----结束");
    }
}

package com.wuk.demo04;

public class MainTest04 {

    public static void main(String[] args) throws InterruptedException {

        CountOperate04 countOperate04 = new CountOperate04();
        Thread thread = new Thread(countOperate04);
        System.out.println("main---begin--"+thread.isAlive());
        thread.setName("A");
        thread.start();
        System.out.println("main---end--"+thread.isAlive());
        Thread.sleep(1000);
        System.out.println("main--sleeped-end--"+thread.isAlive());


    }


}

CountOperate----开始
CountOperate----this--name--Thread-0
CountOperate----this--isAlive--false
CountOperate----结束
main---begin--false
main---end--true
run----开始
run---currentThread--Thread--name--A
run----currentThread--Thread--isAlive--true
run----currentThread--this--name--Thread-0
run----currentThread--this--isAlive--false
run----结束
main--sleeped-end--false

3 sleep()方法

作用是在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。

4 getId()方法

作用是获取线程的唯一标识。

5 停止线程

5.1 停止不了的线程

interrupt()并不会真正停止线程。
interrupted() 测试当前线程是否已经中断，执行后会将状态标志清除为false。
isInterrupted() 测试线程Thread对象是否已经是中断状态，不清除状态。

5.2能停止的线程-异常法

package com.wuk.demo05;

public class MyThread05 extends Thread {

    @Override
    public void run() {
        try {
            for (int i = 0; i <5000; i++) {
                if(this.interrupted()){
                    System.out.println("线程已经停止"+i);
                    throw new InterruptedException();
                }
                System.out.println("i="+i);
            }
            System.out.println("for循环下面的代码");
        }catch (InterruptedException ex){
            ex.printStackTrace();
        }


    }
}

package com.wuk.demo05;

public class MainTest05 {

    public static void main(String[] args) throws InterruptedException {
        MyThread05 t1 = new MyThread05();
        t1.start();
        Thread.sleep(50);
        t1.interrupt();
        System.out.println("是否停止1=" + t1.interrupted());
        System.out.println("是否停止2=" + t1.interrupted());
        System.out.println("end");
    }

}

在这里插入图片描述

5.3 在沉睡中停止

package com.wuk.demo05;

public class MyThread05 extends Thread {

    @Override
    public void run() {
        try {
            System.out.println("begin-------");
            Thread.sleep(5000);
            System.out.println("end--------");
        }catch (InterruptedException ex){
            System.out.println("在线程沉睡中终止他"+this.isInterrupted());
            ex.printStackTrace();
        }


    }
}

package com.wuk.demo05;

public class MainTest05 {

    public static void main(String[] args) throws InterruptedException {
        MyThread05 t1 = new MyThread05();
        t1.start();
        Thread.sleep(50);
        t1.interrupt();
    }

}

在这里插入图片描述结论：
在线程sleep时候停止它，会直接进入catch语句，并且清除停止状态值。

5.4 能停止的线程-return

package com.wuk.demo05;

public class MyThread05 extends Thread {

    @Override
    public void run() {
            for (int i = 0; i <5000; i++) {
                if(this.isInterrupted()){
                    System.out.println("线程已经停止"+i);
                    return;
                }
                System.out.println("i="+i);
            }
            System.out.println("for循环下面的代码");
    }
}

package com.wuk.demo05;

public class MainTest05 {

    public static void main(String[] args) throws InterruptedException {
        MyThread05 t1 = new MyThread05();
        t1.start();
        Thread.sleep(50);
        t1.interrupt();
        System.out.println("是否停止1=" + t1.interrupted());
        System.out.println("是否停止2=" + t1.interrupted());
        System.out.println("end");
    }

}

在这里插入图片描述

6 暂停线程

用suspend()暂停线程，用resume()恢复线程。
缺点：
1 会造成公共的同步对象的独占，使得其他线程无法对公共对象的访问。

2 会因为线程的暂停而导致数据不同步。

7 yield()方法

作用是放弃当前cpu资源，让其他线程占用，但是放弃时间不确定，有可能刚放弃马上又获取到。

8 线程的优先级

优先级高的会获取较多的CPU资源。
设置线程优先级的方法是：setPriority()。
线程优先级等级为1-10。

8.1 线程优先级的继承性

线程的优先级具有继承性，比如A线程启动B线程，则B线程的优先级与A是一样的。

8.2 优先级具有规则性

高优先级的线程总是大部分优先执行完，但是不代表高优先级的全部被执行完。
同时与线程的调用顺序无关。

8.3 优先级具有随机性

也就是说优先级高的不一定每次都是优先执行。

9 守护线程

守护线程的设置：setDaemon(true)。

package com.wuk.demo05;

public class MyThread05 extends Thread {

    @Override
    public void run() {
            for (int i = 0; i <5000; i++) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("i="+i);
            }
    }
}

package com.wuk.demo05;

public class MainTest05 {

    public static void main(String[] args) throws InterruptedException {
        MyThread05 t1 = new MyThread05();
        //设置t1为main的守护线程
        t1.setDaemon(true);
        t1.start();
        Thread.sleep(1000);
        System.out.println("main停止");
    }

}