线程

线程 Thread

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

window下可以通过任务管理器查看进程

linux 下可以通过ps -fe

进程、线程都可以并行执行， cpu

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

操作系统中有一个组件叫做任务调度器，将cpu的时间片分给不同的程序使用， 微观串行(单核)，宏观并行.（多核cpu可以并行）

好处： 1) 多进程，多线程可以让程序不被阻塞. 2) 充分利用多核cpu的优势，提高运行效率

1.java中的多线程

Thread 类

创建线程方法1：

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

启动线程 t.start()

并行(parallel)和并发(concurrent)

创建线程的方法2：

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

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

例子：

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

        Runnable r = () -> System.out.println("hello");

        // () -> System.out.println("hello");

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

2. 线程中的常见方法

Thread.sleep(long n); // 让当前线程休眠n毫秒 Thread.currentThread(); // 找到当前线程

main 方法实际是由主线程（main）来调用的

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

实例方法： start() 让线程启动, 只能调用一次，如果调用了多次会出现IllegalThreadStateException

直接调用run和使用start间接调用run的区别： 直接调用run是在主线程中执行了run，没有启动新的线程 使用start是启动新的线程，通过新的线程间接执行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);
    }

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

3. 线程的并发（Concurrent）

synchronized (同步关键字)

语法

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

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

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

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

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

4. 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;
}

一个线程对run变量的修改对于另一个线程不可见，导致了另一个线程无法停止

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

5. synchronized的另外两种写法

public synchronized void test() {

}
等价于
public void test() {
	synchronized(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(); 让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();
}

}

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

wait(long n) 有时限的等待, 到n毫秒后结束等待，或是被notify

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

8. 线程的状态

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

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

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

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

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

TERMINATED （终止）当线程代码运行结束

五种状态: 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();
}
```# 线程

t1  输出 ++++++++++++++
t2 输出 -----------------------
t3 输出  ****************

t1 obj.wait()  flag==1
t2 obj.wait() flag ==2
t3 obj.wait() flag ==3 

jdk 1.5  5.0

## java.util.concurrent.* java并发工具包

### 1. 创建线程的第三种方式
```java
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;
}

与Runnable的区别，1）有返回结果，2）可以抛出检查异常

创建代码：

// 代表一个任务对象
// 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());

2. 线程池

创建有限的线程资源为更多的任务提供服务。享元模式

// java中对线程池的抽象：ExecutorService  创建一个固定大小的线程池
ExecutorService threadPool = Executors.newFixedThreadPool(2);

/*for (int i = 0; i < 10; i++) {
    threadPool.submit(()->{
        System.out.println(Thread.currentThread().getName()+"任务执行");
    });
}*/
// 执行带有返回结果的任务
Future future = threadPool.submit(() -> {
    System.out.println(Thread.currentThread().getName()+"执行计算...");
    Thread.sleep(1000);
    return 10;
});
System.out.println(future.get());


threadPool.shutdown(); // 不接收新任务，当所有任务运行结束，整个线程池关闭

一个核心的ExecutorService的实现类：ThreadPoolExecutor

ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue)

corePoolSize 核心线程数目 (最多保留的线程数) 5 maximumPoolSize 10

workQueue 阻塞队列 如果任务超过了核心线程数，进入队列进行排队，直到有空闲的线程 10

如果任务过多，阻塞队列都放不下了，还会创建新的线程来救急 corePoolSize+救急的线程 <= maximumPoolSize(最大线程数) 21 会抛出拒绝提交任务异常

keepAliveTime 生存时间- 针对救急线程 60 unit 时间单位 秒

// 创建固定大小的线程池 Executors.newFixedThreadPool(2); 核心线程数=最大线程数（没有救急线程被创建） 阻塞队列 ×××，可以放任意数量的任务, 适合执行数量有限，长时间运行的任务

// 创建缓冲线程池 Executors.newCachedThreadPool() 核心线程数是0， 最大线程数是Integer的最大值(救急线程可以无限创建) 生存时间是60s 适合任务数比较密集，但每个任务执行时间较短的情况

// 创建单线程线程池 Executors.newSingleThreadExecutor() 使用场景：希望多个任务排队执行

区别： Executors.newSingleThreadExecutor() 线程个数始终为1，不能修改 Executors.newFixedThreadPool(1) 初始时为1，以后还可以修改

// 带有日程安排功能的线程池

ScheduledExecutorService service = Executors.newScheduledThreadPool(5);

// 让任务推迟一段时间执行
// 参数1.任务对象， 参数2,3 推迟的时间
/*service.schedule(()->{
    System.out.println("执行任务...");
}, 10L, TimeUnit.SECONDS);*/

// 以一定的频率反复执行任务(任务不会重叠)
// 参数1，任务对象， 参数2，初始推迟时间, 参数3，4 时间间隔和单位
/*service.scheduleAtFixedRate(()->{
    try {
        Thread.sleep(1200);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("hello");
}, 0, 1, TimeUnit.SECONDS);*/

// delay表示从上一个任务结束，到下一个任务开始之间的时间
service.scheduleWithFixedDelay(()->{
    System.out.println("hello");
}, 0, 1, TimeUnit.SECONDS);


//        service.shutdown();

3. 原子操作类

AtomicInteger AtomicBoolean ...

// 创建原子整数类
private static AtomicInteger i = new AtomicInteger(0);

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        for (int j = 0; j < 5000; j++) {
            i.getAndIncrement();  // 获取并且自增  i++
//                i.incrementAndGet();  // 自增并且获取  ++i
        }
    });

    Thread t2 = new Thread(() -> {
        for (int j = 0; j < 5000; j++) {
            i.getAndDecrement(); // 获取并且自减  i--
        }
    });

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

4. 线程安全集合类

StringBuffer 线程安全 String 不可变类 , 都是线程安全的 Random 线程安全 Vector 实现了List，并且线程安全 Hashtable 实现了Map，并且线程安全

5.0新增的线程安全集合类 ConcurrentHashMap 实现了Map，并且线程安全 ConcurrentSkipListMap 实现了Map(可排序)，并且线程安全 CopyOnWriteArrayList 实现了List，并且线程安全

BlockingQueue 阻塞队列 队列 FIFO , first in first out

Queue --> LinkedList

private static BlockingQueue<Product> queue = new ArrayBlockingQueue<>(5);
public static void main(String[] args) {

    // 生产者线程
    new Thread(()->{
        for (int i = 0; i < 10; i++) {
            Product p = new Product(i);
            System.out.println(Thread.currentThread().getName()+"生产了:"+p);
            try {
                queue.put(p);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }).start();

    // 消费者线程
    for (int j = 0; j < 5; j++) {
        new Thread(()->{
            for (int i = 0; i < 2; i++) {
                try {
                    Product p = queue.take();
                    System.out.println(Thread.currentThread().getName()+"消费了:"+p);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }


}

5. ThreadLocal

//             线程局部变量
private static ThreadLocal<SimpleDateFormat> local = new ThreadLocal() {
@Override        // 初始值
protected Object initialValue() {
    return new SimpleDateFormat("yyyy-MM-dd"); // 存入当前线程
}
};


public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
    new Thread(()->{
        try {
            SimpleDateFormat sdf = local.get(); // 获取本线程自己的局部变量
            Date date = sdf.parse("1951-10-09"); // 每个线程使用的是自己的SimpleDateFormat因此没有争用
            System.out.println(Thread.currentThread().getName() + " " + date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }).start();
}

/*for (int i = 0; i < 10; i++) {
    new Thread(()->{
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date date = sdf.parse("1951-10-09");
            System.out.println(Thread.currentThread().getName() + " " + date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }).start();
}*/