Thread类常用操作

一，Thread类的常用操作

线程创建：

1，继承Thread类，重写run方法

class MyThread2 extends Thread{
    @Override
    public void run() {
        System.out.println("hello wuya");
    }
}

还可以使用匿名内部类实现，写法如下：

        Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println("hello wuya");
            }
        };

2，实现runnable接口

class MyThread3 implements Runnable{
    @Override
    public void run() {
        System.out.println("hello wuya");
    }
}

同样也可以使用匿名内部类来实现

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello wuya");
            }
        });

3，使用lambda表达式

        Thread thread2 = new Thread(()->{
            System.out.println("hello wuya");
        });

线程休眠与中断：

线程休眠使用的是Thread中的sleep方法，作用是使当前线程休眠( 暂停执行 )所指定的时间( 单位为毫秒 )，当休眠被其他线程中断时会抛出 InterruptedException 异常并将 IsInterrupted 状态置为false；用法如下：

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

使用例子如下：

    private static long count;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            Thread.currentThread().interrupt();
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(2000);
                    System.out.println("iam sleeping");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        t1.interrupt();
        t1.join();
    }

运行结果：

结果表明，当线程 t1 睡眠状态被打断后会抛出异常并将自身的 IsInterrupted 状态置为 false 之后继续运行，若想要在 interrupted 后终止运行只需修改异常捕获中的 catch{ } 中的代码，如下：

try {
    Thread.sleep(2000);
    System.out.println("iam sleeping");
} catch (InterruptedException e) {
    e.printStackTrace();
    break;
}

 得到以下结果：

线程等待：

由于各线程抢占式执行，所以每个线程被调用执行的顺序是随机的，线程等待可以在一定程度上规范线程的执行顺序，实现线程等待是Thread中的 join 方法，作用是使当前线程加入指定线程，加入的含义是等待指定线程执行结束后开启或继续当前线程，示例如下：

    private static long count;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for (long i = 0; i < 100_0000_0000L; i++) {
                count++;
            }
        });
        long beg = System.currentTimeMillis();
        t1.start();
        //t1.join();
        for (long i = 0; i < 100_0000_0000L; i++) {
            count++;
        }
        long end = System.currentTimeMillis();
        System.out.println("executed time: "+(end-beg));
    }

代码解释如下：在未加入 join() 之前，线程 main 和 t1 并发执行，当加入 join() 之后，两个线程串行执行( 即 main 线程在等待 t1 执行结束之后再继续执行 )，因此加入 join() 之后，程序执行时间会增长，运行结果：

加入 join() 前：

加入 join() 后：

获取线程实例：

获取当前线程实例，同样也是使用 Thread 中的方法，调用该方法之后会返回当前线程实例，用例如下：

public class ThreadDemo17 {
    public static void main(String[] args) {
        //获取 main 线程实例 并调用获取当前线程状态的方法
        System.out.println(Thread.currentThread().getState());
    }
}

运行结果：

下面我们再来谈谈Java线程的六种生命周期状态-------

二，Java线程的六种生命周期状态

首先介绍以下如何获取某个线程的状态，可以通过线程引用调用 getState() 方法获取，而main线程的状态获取则先通过获取线程实例之后再调用 getState() 方法

NEW:

NEW 状态指线程创建后尚未启动的状态。

    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            System.out.println("hello");
        });
        System.out.println(t1.getState());
        t1.start();
    }

RUNNABLE:

RUNNABLE   指该线程处于就绪或运行状态

    private static long count;
    public static void main(String[] args) throws InterruptedException {
        Thread t2 = new Thread(()->{
            for (long i = 0; i < 100_0000_0000L; i++) {
                count++;
            }
        });
        t2.start();
        System.out.println(t2.getState());
        t2.join();
    }

BLOCKED:

BLOCKED  指线程处于阻塞状态

当线程想要使用上锁的代码，就会由 RUNNABLE 状态转化为 BLOCKED 状态

WAITING:

处于该状态的线程不会被分配执行时间，需要等待被其他线程显式唤醒

TERMINATED:

线程任务执行结束时处于这种状态

TIMED_WAITING:

计时等待状态的线程，不会被操作系统分配执行时间，也不需要被其他线程显式唤醒，在计时结束后由操作系统自动唤醒

三，常见的线程安全问题的发生

先举个例子来引入线程安全问题：

public class ThreadDemo15 {
    private static long count;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            for (long i = 0; i < 50000L; i++) {
                count++;
            }
        });
        Thread t2 = new Thread(()->{
            for (long i = 0; i < 50000L; i++) {
                count++;
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("count: "+count);
    }
}

简单介绍一下以上代码：分别建立并运行t1,t2两个线程，在这两个线程中都对静态变量count进行5w次自增操作，在直观感受上，结果应该为10w，下面来看一下运行结果：

多次运行之后发现结果是大概基于5w ~ 10w的一个数，在解开谜底之前需要先介绍一个知识：

count++; 这行代码究竟是如何执行的？

事实上count++是由三个CPU指令构成的，分别是，load：把内存数据加载到寄存器中；add：将count加 1 ；save：把寄存器数据写回到内存中。

由于这三个CPU指令存在执行间隔，因此所举得的例子中发生的事情正是：在寄存器未执行线程 t1 的 save 时，另外一个寄存器开始执行 t2 的 load；导致 t2 读取到了错误的数据；因此虽然对count进行了两次自增操作，但是结果只让count加到了1。借助下图来理解以下：( 寄存器1代表 t1 线程， 寄存器2代表 t2 线程 )

那么发生此问题时该如何解决呢，常见的方式时加锁，即当一个寄存器在执行某个{ load, add, save }时，其他寄存器无法进行 load 操作，只有在执行操作的寄存器完成 save 之后才会解锁，在加锁的过程中，其他试图访问的线程都会出于 BLOCKED 状态，直到解锁之后才会恢复到 RUNNABLE 状态。

加锁操作使用到的方法时 synchronized ；具体的使用方法如下：

public class ThreadDemo16 {
    private static long count;
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 5_0000; i++) {
                synchronized (locker){
                    count++;
                }
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 5_0000; i++) {
                synchronized (locker){
                    count++;
                }
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("count: "+count);
    }
}

synchronized ( 需要上锁的线程需要使用的相同的对象 ) { 需要实现的线程安全的代码 };