(一)java多线程之Thread

Thread类

学习java线程的开发者,首先遇到的第一个类就是Thread,通过使用Thread类,我们就可以启动,停止,中断一个线程. 在同一个时间片里, 可能会有多个线程在执行, 每个线程都拥有它自己的方法调用堆栈, 参数和变量.每个app至少会有一个线程--主线程(main thread).

创建一个线程

java创建线程有两种方式

1. 创建一个继承Thread的子类,并实现run方法
2. 使用Thread的构造方法public Thread(Runnable target)创建,这个需要传入一个实现Runnable接口的子类

实现

下面我们分别以这两种方式实现一下.

• 编写SubThread继承Thread,并覆盖run方法 SubThread.java

public class SubThread extends Thread{    @Override    public void run() {        for (int i = 0; i < 10; i ++){            System.out.println(Thread.currentThread().getName() + ":" + i);        }    }    public static void main(String[] args) {        System.out.println("begin main");        SubThread sub = new SubThread();        sub.start();        System.out.println("end main");    }}

• 编写SubRunnable实现Runnable,然后使用构造器Thread(Runnable) 创建一个线程

public class SubRunnable implements Runnable {    @Override    public void run() {        for (int i = 0; i < 10; i ++){            System.out.println(Thread.currentThread().getName() + ":" + i);        }    }    public static void main(String[] args) {        System.out.println("begin main");        Thread thread = new Thread(new SubRunnable());        thread.start();        System.out.println("end main");    }}

区别

• 使用第一种方法创建的话,你可以在run方法中,可以用this直接调用线程的方法,比如获取线程的id-->this.getId()
• 而使用第二方法创建线程,在run中,this对象压根就没有getId()这个方法,这个时候你只能用Thread.cuurentThread()这个静态方法获取该线程.
• 在这里一般推荐使用第二种方法创建,因为这样比较符合面对象的思路,Thread就只负责线程的启动,停止,中断等操作,而Runnable就只负责线程要运行某一个具体任务.

不管使用那种方式创建线程,都可以调用Thread.cuurentThread()获取当前的线程
还有,Thread其实也是Runnable的一个子类
除了上面两种创建方法,其中还有另外一种方法创建线程,那就是实现ThreadFactory接口,这种比较适合批量生成某一种规格的线程

让线程"睡"一会

调用线程的Thread.sleep()方法会让线程睡眠一段时间,这个时候线程会挂起,然后将CPU的时间片转移给其他线程,让其他线程获得执行的机会.

Thread.sleep()接收一个毫秒值做完参数,并抛出一个InterruptedException异常.

停止线程

不管是使用哪一种方法创建线程,run方法的任务执行完了,线程就自动停止.
如果想在中途就停止线程,有下面几种方式

• 调用线程的interrupt()方法,这时线程的中断位会被标识,并抛出InterruptedException,例如:

public class StopThread1 {    public static void main(String[] args) throws InterruptedException {        System.out.println("begin main");        Thread thread = new Thread(new Runnable() {            @Override            public void run() {                for (int i = 0; i < 10; i ++){                    try {                        Thread.sleep(100);                        System.out.println(Thread.currentThread().getName() + ":" + i);                    } catch (InterruptedException e) {                        break;                    }                }            }        });        thread.start();        System.out.println("main sleep 500ms");        Thread.sleep(500);        thread.interrupt();        System.out.println("end main");    }}

在调用thread.interrupt();这个语句时,会对该线程的中断状态标识为true,然后在抛出InterruptedException异常时,会清空该中断位.
修改程序,在抛出InterruptedException中添加System.out.println("InterruptedException:" + Thread.currentThread().isInterrupted());,然后再thread.interrupt();后面添加System.out.println("thread.isInterrupted:" + thread.isInterrupted());.然后运行程序.

这时候运行结果有可能打印出thread.isInterrupted:true;InterruptedException:false或者打印出thread.isInterrupted:false;InterruptedException:false,运行多次结果都有可能不一致,这个是因为主线程和子线程都通知在执行,还没有来的及执行主线程的打印语句,子线程异常中的打印语句就已经执行了.

• 可以在线程中加一个boolean成员变量,提供setter方法,然后在run方法中判断该变量是否为true,若为true则停止线程,否则继续

public class StopThread2 {    public static class StopRunnable implements Runnable{        private boolean isStop = false;        public void setStop(){            this.isStop = true;        }        @Override        public void run() {            int count = 0;            while (!isStop){                try {                    Thread.sleep(100);                    System.out.println(Thread.currentThread().getName() + ":" + count++);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }    }    public static void main(String[] args) throws InterruptedException {        System.out.println("begin main");        StopRunnable stop = new StopRunnable();        Thread thread = new Thread(stop);        thread.start();        Thread.sleep(200);        stop.setStop();        System.out.println("end main");    }}

线程的属性

• id: 通过Thread.getId()可以获取线程的id,线程的id是一个自增长的long, 不能修改
• name: 通过Thread.getName(), 用一个字符串来标识线程的名字,可以通过Thread.setName()或部分构造器修改线程的名字
• priority: 线程的优先级,线程创建默认优先级为5, 最小为优先级为1, 最大为10.优先级大的线程有机会先执行.但具体那个线程先执行还是要看CPU的心情了.
• state: 线程的状态, 线程的状态有以下几种
  • Thread.State.NEW: 新建状态:这个是线程已经被创建但还没有调用'start()'方法时的状态
  • Thread.State.RUNNABLE: 运行状态 当前线程已经在JVM中执行
  • Thread.State.BLOCKED: 阻塞状态 表示当前线程在等待进入一个同步块或同步方法,也可以等到一个同步快被提交. 常见的有IO阻塞等.
  • Thread.State.WAITING: 等待状态 但线程调用Object.wait(),Thread.join(),LockSupport.park()就会进入等待状态.当前线程在等待其他线程执行某一个特定操作.比如:当前线程执行Object.wait(),那么就需要其他线程执行Object.notify()或Object.notifyAll(),如果线程执行了Thread.join(),则需要等到指定的线程执行结束.
  • Thread.State.TIMED_WAITING: 有时间的等待 线程在等待某一个等待的时间.比如,线程执行了Thread.sleep,Object.wait(long),Thread.join(long)等
  • Thread.State.TERMINATED: 终结 线程已经执行完毕.
• daemon: 这个用来标识线程为守护线程或非守护线程的,默认创建的线程都是非守护线程.应用程序所有的非守护线程执行完毕之后,则程序就停止运行.比如主线程都是非守护线程,所以主线程会等到主线程的所有语句执行完成,程序才会停止运行.JVM的资源回收则是一个守护线程.

public class TestDaemonThread {    public static void main(String[] args) {        System.out.println("start main");        Thread thread = new Thread(new Runnable() {            @Override            public void run() {                for (int i = 0; i < 10; i ++){                    try {                        System.out.println(Thread.currentThread().getName() + ":" + i);                        Thread.sleep(10);                    } catch (Exception e) {                        e.printStackTrace();                    }                }            }        });        thread.start();        System.out.println("end main");    }}

该例子中,程序必须等到主线程和子线程同时执行完成才会停止,因为默认创建的线程都是非守护线程,如果在thread.start();前加入thread.setDaemon(true);, 那么程序不会等子线程执行完才结束程序的.

Thread.join()

等到某线程执行完毕才开始执行,如果调用Thread.join(long)则表示等到某线程执行完毕或指定的超时时间结束后才开始执行

public class ThreadJoinTest {    public static void main(String[] args) throws InterruptedException {        Thread thread1 = new Thread(() -> {            for (int i = 0;i < 10; i ++){                try {                    Thread.sleep(10);                    System.out.println(Thread.currentThread().getName() + ":" + i);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }, "thread1");        Thread thread2 = new Thread(() -> {            try {                thread1.join();                for (int i = 0;i < 10; i ++){                    Thread.sleep(10);                    System.out.println(Thread.currentThread().getName() + ":" + i);                }            } catch (InterruptedException e) {                e.printStackTrace();            }        }, "thread2");        thread1.start();        thread2.start();    }}

上面的例子,thread2线程会等thread1执行完之后才开始执行

Thread.yield

这个方法标识当前线程会按时线程调度者让其他线程先执行.但CPU是否让其他线程优先执行,还是要看CPU的心情了.

线程的异常

如果线程发现一些运行时异常而没有在run方法俘获,会怎么办?

程序会打印出一推错误堆栈,如果我们先把线程的错误按照某种可读的方式打印到问题,但又不想在每个run方法中增加try{...}catch(Exception e){...}怎么办?
我们查看Thread类的源码发现,在Thread中有一个内部接口UncaughtExceptionHandler,这个正是我们所需要的.实现这个接口,并调用Thread.setUncaughtExceptionHandler,那么但线程出现时,则会回调uncaughtException方法

public class ThreadExceptionTest {    public static void main(String[] args) throws InterruptedException {        System.out.println("begin main");        Thread thread = new Thread(() -> {            int i = 1 / 0;        },"myThread");        thread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {            @Override            public void uncaughtException(Thread t, Throwable e) {                System.out.println(String.format("%s发生异常%s", t.getName(), e.getMessage()));            }        });        thread.start();        System.out.println("end main");    }}