Java中你所需要了解的线程Thread知识

线程 Thread

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

windows系统下可以通过任务管理器查看进程
Linux 下可以通过ps-fe
进程，线程都可以并行执行，CPU

---程序1
                ---程序2
                        ---程序1

操作系统中有一个组价叫任务调度器，将cpu的时间分给不同的程序使用，微观上是串行执行（单核），宏观上是并行。（多核CPU才能真正实现并行）

好处：
    1）多进程和多线程可以让程序不被堵塞。
    2）充分利用多核CPU的优势，提高运行效率。

1.Java中的多线程

Thread类

创建线程方法1：

Thread t =new Thread(){
   public void run(){//运行
   //线程需要执行的代码
   //不能抛出检查异常，只能自己处理检查异常
   }
};

 Thread t1=new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    System.out.println(Thread.currentThread()+"###############");
                }

            }
        };

启动线称 start（）；
Ctrl+ O   方法重写

并行(parallel)和并发（concurrent）

创建线程的方法2：

把线程和要执行的代码分开
Thread 代表线程
Runnable可运行的 （线程要执行的代码）

Runnable runnable= new Runnable（）{
public void run(){
//要执行的代码
    };
}
Thread t = new Thread(runnable对象)
t.start();

  
     /*   Runnable run=new Runnable() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        };*/
        Runnable run = () -> System.out.println("hello");//使用


        Thread t = new Thread(run);
        t.start();

2.线程中的常见方法

Thread.sleep(long n);让当前线程休眠n秒  把CPU让出去，不影响其他线程。

---

Thread.currentThread();找到当前线程  toString的形式打印
main也是个特殊的线程，叫主线程（main)

注意：可以使用jconsle来查看某个Java进程中线程的运行情况

实例方法
start（）；让线程启动，只能调用一次，如果调用多次会抛出异常 IllegalThreadException

直接调用run和使用start间接的调用run的区别：
直接调用run是在主线程中执行了run，没有启动新线程。
使用start是启动新的线程。

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);
    }

jion(long n);表示等待这个线程结束，最多等待n毫秒。

getName(); 得到线程的名称
yield ()      谦让  用法：调试时用

不推荐使用的方法:
stop(); 让线程停止
.suspend ()让线程暂停
.resume() 让线程继续

默认情况下，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);

interrupt() 可以打断正在等待的线程（包括sleep, join的等待）例如：

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();

.interrupt()可以打断正在等待的进程
 ## 3.线程的并发（concurrent）
 
 synchronized (同步关键字) （保证代码块内变量可见性和代码块的原子性。属于重量级操作，性能会受到影响）

语法

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

用synchronized 解决并发问题：

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

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {//甲
            for (int j = 0; j < 60000; j++) {
                synchronized (obj) { // 甲会锁住这个房间
                    i++;
                }
            }
        });
        Thread thread2 = new Thread(() -> {//乙
            for (int j = 0; j < 60000; j++) {
                synchronized (obj) { // 乙   在门外等待
                    i--;
                }
            }
        });
        thread.start();
        thread2.start();

        thread.join();
        thread2.join();
        System.out.println(i);
    }

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

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

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

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

4.volatile 易变的 （只保证可见性）

一个线程对变量的修改，其他线程不可见。

用volatile可以修饰成员变量，静态成员变量。他可以防止线程从自己的高速缓存中查找变量的值，必须到主存中获取他的值。

高速缓存：取值特别频繁才会产生高速缓存。

他保证的是变量在多个线程之间的可见性，不能保证原子性。

public class Testvolatile {
 volatile    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;
    }

5.synchronized的另外两种写法

public synchronized void test(){

}
等价于
public void test(){
    synchronized(this){
    }
}
//锁住普通方法，相当于锁住调用他的对象this
class Test{
    public  synchronized static void test{

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

锁住静态方法，相当于锁住类对象

6.线程死锁

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();

检测死锁可以使用 jconsole工具

7.wait() notify() notifyAll()

都属Object对象的方法,必须先获得此对象的锁，才能调用这几个方法

wait() 等待
notify()唤醒
他们都是线程之间进行协作的手段

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

public static void main(String[] args) {
Object obj=new Object();
new Thread(()->{
    synchronized (obj){
        System.out.println("xianchen");
        try {

            obj.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("执行完");
    }
}).start();
new Thread(()->{
    synchronized (obj){
        System.out.println("xianchen2");
        try {

            obj.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("执行完le");
    }
}).start();
try {
    Thread.sleep(2000);
} catch (InterruptedException e) {
    e.printStackTrace();
}
synchronized (obj){
    obj.notify();
}
System.out.println("over");
}
}

wait（）方法实际是会释放对象的锁，进入WaitSet等待区，从而让其他线程获取对象的锁。无限制等待，直到nofity为止。

wait（n） 有时限的等待，到n毫秒后结束等待，或是被notify

面试题：sleep（long）睡眠n毫秒，而wait（long）是等待n毫秒
1）sleep是Thread方法，而wait是Object方法。
2）sleep不需要强制和Synchronized配合使用，但wait需要和Synchronized一起用
3）sleep在睡眠的同时，不会释放对象锁的，但wait在等待的时候会释放对象锁。

线程的状态

NEW（新建）    线程刚被创建，但是还没有调用start方法

RUNNABLE（可运行） 当调用了start（）方法之后

BLOCKEd（阻塞）当线程进入了monitor监视器区，处于entrySet里准备竞争锁的时候，叫阻塞状态。

WAITING（等待）当调用了对象的wait方法，或调用了线程对象的join方法，进入了waitSet，处于等待状态。

TIME_WAITING当调用wait（long n）join（long n）进入了waitSet，处于有限时的等待状态。
当调用sleep（long n）时让当前线程放弃cpu的时间片睡觉一会儿

TERMINATED 当线程代码运行结束

五种状态
NEW（新建），RUNNABLE（可运行），ＲＵＮＮＩＮＧ（正在运行），阻塞（ＢＬＯＣＫＥＤ，ＷＡＩＴＩＮＧ，TIME_WAITING），ＴＥＲＭＩＮＡＴＥＤ（终止）

##

五种状态:
NEW(新建), RUNNABLE(可运行) , RUNNING（正在运行）, 阻塞（BLOCKED，WAITING， TIMED_WAITING ）TERMINATED（终止）

9. 如何让两个线程以固定的顺序运行

static Object obj = new Object();
static boolean t2runed = false;// t2是否执行过
// 打印 2， 1
public static void main(String[] args) {

    Thread t1 = new Thread(() -> {
        synchronized (obj) {
            while(!t2runed) { // 如果t2没有执行过
                try {
                    obj.wait(); // 线程t1 先等一会
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(1);
    });

    Thread t2 = new Thread(()->{
        System.out.println(2);
        synchronized (obj) {
            t2runed = true;
            obj.notify();
        }
    });

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