Java中的线程Thread

1.Java中的线程

应用程序以进程为单位运行，一个进程之内可以分为一到多个线程

tips：
windows下可以通过任务管理器查看进程
linux下可以通过ps -fe查看进程
（进程、线程都可以并行执行）

操作系统中有一个组件叫做任务调度器，将cpu的时间片分给不同的程序使用。
单核cpu微观串行，宏观并行。
而多核cpu可以实现真正的并行。
好处：
1) 多进程，多线程可以让程序不被阻塞.
2) 充分利用多核cpu的优势，提高运行效率

1.1.java中的多线程

Thread 类

创建线程的方法1：

继承Thread类：

public class ThreadClient {  

    public static void main(String[] args) {  
        Print p1 = new Print();  
        Print p2 = new Print();  
        p1.start();  
        p2.start();  

    }  

}  

class Print extends Thread{  
    @Override  
    public void run(){  
        for(int i=0;i<10;i++){  
            System.out.println(Thread.currentThread().getName()+":"+i);  
            try {  
                Thread.sleep(2000);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}  

运行结果：

Thread-0:0  
Thread-1:0  
Thread-0:1  
Thread-1:1  
Thread-0:2  
Thread-1:2  
Thread-0:3  
Thread-1:3  
Thread-0:4  
Thread-1:4  
Thread-0:5  
Thread-1:5  
Thread-0:6  
Thread-1:6  
Thread-0:7  
Thread-1:7  
Thread-0:8  
Thread-1:8  
Thread-0:9  
Thread-1:9  

创建线程的方法2：

实现Runnable接口：

public class ThreadClient1 {  

    public static void main(String[] args) {  
        Runnable p1 = new Salesman("Jack");  
        Runnable p2 = new Salesman("Iris");  

        Thread t1 = new Thread(p1);  
        Thread t2 = new Thread(p2);  

        t1.start();  
        t2.start();  
    }  

}  

class Salesman implements Runnable{  

    private int ticket=100;//每个线程都拥有100张票  
    private String name;  
    Salesman(String name){  
        this.name=name;  
    }  

    @Override  
    public void run(){  
        while(ticket>0){  
             System.out.println(ticket--+" is saled by "+name+","+Thread.currentThread().getName());  
            try {  
                Thread.sleep(1000);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
         }  
    }  
}  

运行结果：

10 is saled by Jack,Thread-0  
10 is saled by Iris,Thread-1  
9 is saled by Jack,Thread-0  
9 is saled by Iris,Thread-1  
8 is saled by Jack,Thread-0  
8 is saled by Iris,Thread-1  
7 is saled by Iris,Thread-1  
7 is saled by Jack,Thread-0  
6 is saled by Iris,Thread-1  
6 is saled by Jack,Thread-0  
5 is saled by Iris,Thread-1  
5 is saled by Jack,Thread-0  
4 is saled by Iris,Thread-1  
4 is saled by Jack,Thread-0  
3 is saled by Iris,Thread-1  
3 is saled by Jack,Thread-0  
2 is saled by Iris,Thread-1  
2 is saled by Jack,Thread-0  
1 is saled by Iris,Thread-1  
1 is saled by Jack,Thread-0  

创建线程的方法3：

实现Callable接口：
格式：

public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

测试：

// 代表一个任务对象
// Callable代表线程中要执行的代码
FutureTask task = new FutureTask(new Callable() {
    @Override
    public Object call() throws Exception {
        System.out.println(Thread.currentThread().getName()+"开始执行");
        Thread.sleep(2000);
        return "ok";
    }
});

// 创建和启动新线程
new Thread(task).start();

// 获取返回结果
System.out.println(task.get());

运行结果：

Thread-0开始执行
ok

1.2线程中的常见方法

Thread.sleep(long n); // 让当前线程休眠n毫秒
Thread.currentThread(); // 找到当前线程
Thread.start(); //启动线程
Thread.join(); //等待某个线程执行结束
Thread.join(long n); //表示等待线程结束，但最多等待n毫秒
Thread.getName(); //得到线程的名称
Thread.yield(); //谦让
Thread.interrupt(); //打断正在等待的线程（包括sleep, join）
Thread.stop(); //让线程停止
Thread..suspend(); //让线程暂停
Thread..resume(); //让线程继续
注意：
1. main 方法实际是由主线程（main）来调用的
2. 可以使用jconsole 来查看某个java进程中线程的运行情况
3. start() 只能调用一次，如果调用多次会出现IllegalThreadStateException
4. 直接调用run和使用start()间接调用run的区别：
1）直接调用run()是在主线程中执行了run()，没有启动新的线程
2）使用start()调用run()启动了新的线程，通过新的线程调用run()

join（） 例：

static int r = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1= new Thread(()->{
            System.out.println("t1运行开始");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("t1运行结束");
            r = 100;
        });
        t1.start();

        /*System.out.println("main开始");
        t1.join();
        System.out.println("main结束");*/
        t1.join();
        System.out.println(r);
    }

interrupt（） 例：

Thread t = new Thread(()->{
    try {
        Thread.sleep(5000); // 被打断线程会抛出InterruptedException
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("结束 。。。");
});
t.start();

Thread.sleep(1000);
System.out.println("打断t线程。。。");
t.interrupt();

1.2.1守护线程

默认情况下，java进程需要等待所有线程都运行结束，才会结束。有一种特殊的线程叫做守护线程（守护的是主线程），只要主线程运行结束，即使守护线程的代码没有执行完，也会跟着主线程一起结束。

例：

Thread t1= new Thread(()->{
    System.out.println("守护线程开始执行...");
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("守护线程结束");
});
t1.setDaemon(true); // 设置该线程为守护线程
t1.start();

Thread.sleep(1000);

1.3线程的并发

1.3.1synchronized (同步关键字)

每个对象都有一个自己的monitor（监视器）,当一个线程调用synchronized(对象），就相当于进入了这个对象的监视器。要检查有没有owner，如果没有，此线程成为owner; 但如果已经有owner了，这个线程在entryset的区域等待owner的位置空出来。

成为owner可以理解为获得了对象的锁

在竞争的时候，是非公平的

synchronized必须是进入同一个对象的monitor 才有上述的效果

格式：

synchronized(对象) {
    要作为原子操作代码
}

用synchronized 解决并发问题：

static int i = 0;
static Object obj = new Object(); // 房间，能容纳一个人

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> { // 甲
        for (int j = 0; j < 5000; j++) {
            synchronized (obj) { // 甲会锁住这个房间
                i++;
            } // 甲从房间出来解开了锁
        }
    });

    Thread t2 = new Thread(() -> { // 乙
        for (int j = 0; j < 5000; j++) {
            synchronized (obj) { // 乙   在门外等待
                i--;
            } //
        }
    });
    t1.start();
    t2.start();

    t1.join();
    t2.join();
    System.out.println(i);
}

synchronized的另外两种写法：

synchronized 语句块既可以保证代码块的原子性，也可以保证代码块内变量的可见性。
但缺点是synchronized是属于重量级操作，性能会受到影响。

一：

public synchronized void test() {

}
//等价于
public void test() {
    synchronized(this) {

    }
}

二：

class Test{
    public synchronized static void test() {

    }
}
//等价于
public static void test() {
    synchronized(Test.class) {

    }
}

1.3.2CAS机制（compare And swap 比较并交换）：

synchronized可以称之为悲观锁，而CAS体现的是乐观锁。
原理：
（不会给共享资源加锁，而是做一个尝试）
先拿到旧值，查看旧值是否跟共享区域的值相等
如果不等，那么说明别的线程改动了共享区域的值，我的修改失败
如果修改失败，则重新尝试（自旋）
如果相等，那么我的修改成功

自增案例（i++）：

int var5;
       // 修改失败，没关系，重新尝试
        do {
           // 获取共享区域的最新值
            var5 = this.getIntVolatile(var1, var2); // 10
                    // 比较并交换                     最新值， 最新值+1
        } while(! this.compareAndSwapInt(var1, var2, var5, var5 + var4));

        return var5;

1.3.3重入锁（ReentrantLock）

方法：
.lock() 加锁
.unlock() 解锁

例：

static int i = 0;

public static void main(String[] args) throws InterruptedException {
    ReentrantLock rl = new ReentrantLock();

    Thread t1 = new Thread(() -> {
        for (int j = 0; j < 5000; j++) {
            try {
                rl.lock(); // 加锁
                i++;
            } finally {
                rl.unlock(); // 保证解锁一定被执行
            }
        }
    });

    Thread t2 = new Thread(() -> {
        for (int j = 0; j < 5000; j++) {
            try {
                rl.lock(); // 加锁
                i--;
            } finally {
                rl.unlock(); // 保证解锁一定被执行
            }
        }
    });

    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println(i);
}

运行结果：

0

与synchronized的区别：
ReentrantLock 在高并发下性能较高，内存占用也较大。

1.4 volatile（易变的）

可以用来修饰成员变量和静态成员变量，可以防止线程从自己的高速缓存中查找变量的值，必须到主存中获取它的值。
tips：它保证的是变量在多个线程之间的可见性， 但不能保证原子性。

static boolean run = true;

public static void main(String[] args) throws InterruptedException {
    Thread t = new Thread(()->{
        while(run){
            // ....
        }
    });
    t.start();

    Thread.sleep(1000);
    run = false;
}
//一个线程对run变量的修改对于另一个线程不可见，导致了另一个线程无法停止

1.5线程死锁

a线程获得了A对象的锁
接下来需要获取B对象的锁
b线程获得了B对象的锁
接下来需要获取A对象的锁

Object A = new Object();
Object B = new Object();


Thread a = new Thread(()->{
    synchronized (A) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (B) {
            System.out.println("操作...");
        }
    }
});

Thread b = new Thread(()->{
    synchronized (B) {
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (A) {
            System.out.println("操作...");
        }
    }
});
a.start();
b.start();

tips：检测死锁可以使用 jconsole工具

1.6wait() notify() notifyAll()

都属于Object对象的方法，它们都是线程之间进行协作的手段

obj.wait(); 让object监视器的线程等待
obj.notify(); 让object上正在等待的线程中挑一个唤醒
obj.notifyAll(); 让object上正在等待的线程全部唤醒

必须获得此对象的锁，才能调用这几个方法

例：

Object obj = new Object();

new Thread(()-> {
    synchronized (obj) {
        System.out.println("thread-0线程执行....");
        try {
            obj.wait(); // 让线程在obj上一直等待下去
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("thread-0其它代码....");
    }
}).start();

new Thread(()-> {
    synchronized (obj) {
        System.out.println("thread-1线程执行....");
        try {
            obj.wait(); // 让线程在obj上一直等待下去
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("thread-1其它代码....");
    }
}).start();

try {
    Thread.sleep(2000);
} catch (InterruptedException e) {
    e.printStackTrace();
}
System.out.println("唤醒obj上其它线程");
synchronized (obj){
//            obj.notify();
    obj.notifyAll();
}

}

1.7CountDownLatch（倒计时）

使用场景：当希望多个线程执行完毕后，再进行下一步操作时。

例：

public static void main(String[] args) throws InterruptedException {
    CountDownLatch cdl = new CountDownLatch(3);// 构造方法需要指定倒计时的数字
    new Thread(()->{
        System.out.println("线程1开始运行"+new Date());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程1准备完成"+new Date());
        cdl.countDown();
    }).start();
    new Thread(()->{
        System.out.println("线程2开始运行"+new Date());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程2准备完成"+new Date());
        cdl.countDown();
    }).start();
    new Thread(()->{
        System.out.println("线程3开始运行"+new Date());
        try {
            Thread.sleep(1500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程3准备完成"+new Date());
        cdl.countDown();
    }).start();

    // 主线程等待，直到倒计时为0
    System.out.println("主线程等待");
    cdl.await();
    System.out.println("ready go....");
}

运行结果：

主线程等待
线程1开始运行Thu Aug 16 14:53:58 CST 2018
线程2开始运行Thu Aug 16 14:53:58 CST 2018
线程3开始运行Thu Aug 16 14:53:58 CST 2018
线程2准备完成Thu Aug 16 14:53:59 CST 2018
线程3准备完成Thu Aug 16 14:54:00 CST 2018
线程1准备完成Thu Aug 16 14:54:00 CST 2018
ready go....

模拟十个玩家加载进度例子：

public static void main(String[] args) throws InterruptedException {
    CountDownLatch latch = new CountDownLatch(10);
    String[] all = new String[10];

    for (int j = 0; j < 10; j++) {
        int x = j;
        new Thread(()->{
            Random r = new Random();
            for (int i = 0; i <= 100; i++) {
                try {
                    Thread.sleep(r.nextInt(100));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (all){
                    all[x]=(i+"%");
                    System.out.print("\r"+Arrays.toString(all));
                }
            }
            latch.countDown();

        }).start();
    }

    latch.await();
    System.out.println("\nend...");
}

运行结果：

[100%, 100%, 100%, 100%, 100%, 100%, 100%, 100%, 100%, 100%]
end...

1.8CyclicBarrier（循环栅栏）

使用场景：当满足CyclicBarrier设置的线程个数时，则继续执行，不满足则等待

例：

CyclicBarrier cb = new CyclicBarrier(2); // 个数为2时才会继续执行

new Thread(()->{
    System.out.println("线程1开始.."+new Date());
    try {
        cb.await(); // 当个数不足时，等待
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (BrokenBarrierException e) {
        e.printStackTrace();
    }
    System.out.println("线程1继续向下运行..."+new Date());
}).start();

new Thread(()->{
    System.out.println("线程2开始.."+new Date());
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    try {
        cb.await(); // 2 秒后，线程个数够2，继续运行
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (BrokenBarrierException e) {
        e.printStackTrace();
    }
    System.out.println("线程2继续向下运行..."+new Date());
}).start();

与CountDownLatch（倒计时）的区别：
CountDownLatch只能使用一次，结束后此对象就没用了，而CyclicBarrier可以重复利用。

1.9 信号量

使用场景：限制了能同时运行的线程上限

Semaphore s = new Semaphore(3); // 限制了能同时运行的线程上限
for (int i = 0; i < 10; i++) {
    new Thread(() -> {
        try {
            s.acquire(); // 获得此信号量
            System.out.println("我是线程" + Thread.currentThread().getName());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            s.release(); // 释放信号量
        }

    }).start();
}

1.10线程的状态

五种状态：
NEW(新建), RUNNABLE(可运行) , RUNNING（正在运行）, 阻塞（BLOCKED，WAITING， TIMED_WAITING ）TERMINATED（终止）
NEW(新建) 线程刚被创建，但是还没有调用 start方法

RUNNABLE(可运行)
当调用了start() 方法之后

RUNNING(正在运行)

BLOCKED(阻塞)
当线程进入了monitor监视器区，处于entrySet里准备竞争锁的时候，处于阻塞状态

WAITING(等待)
当调用了对象的wait方法，或调用了线程对象的join方法，进入了WaitSet，处于等待状态

TIMED_WAITING(限时等待)
当调用wait(long n) join(long n) 进入了WaitSet，处于有限时的等待状态
当调用sleep(long n) 是让当前线程放弃cpu的时间片，睡眠一会

TERMINATED(终止)当线程代码运行结束