10、多线程与并发 - 《Java 基础内容学习》

1、进程与线程
2、线程的基本使用
- (1）继承Thread类，重写run方法
- (2）实现Runnable接口，重写run方法(推荐使用)
3、线程休眠
Example：ThreadDemo1
4、join与中断线程
Example：ThreadDemo2
5、守护线程与yield
6、其他方法与优先级
Example：ThreadDemo3
7、线程同步
Example：ThreadDemo4
8、死锁
9、生产者与消费者应用案例
10、线程的生命周期
11、线程池
Example：ThreadDemo5

1、进程与线程

1）进程

程序是指令与数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。

进程是程序在处理机上的一次执行过程，是一个动态概念。

进程是一个具有一定独立功能的程序，一个实体，每一个进程都有自己的地址空间。

2）进程的状态

进程执行时的间断性，决定了进程可能具有多种状态。事实上，运行中的进程具有以下三种基本状态：

1）就绪状态（Ready）
2）运行状态（Running）
3）阻塞状态（Blocked）

10、多线程与并发 - 图1

3）线程

线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干程序又可以划分成若干个线程。

线程：是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行，一个进程最少有一个线程（单线程程序）

一个程序可以同时执行多个任务，来提高效率。
例如：
（1）同时下载多个电影
（2）同时与多人聊天

4）并行与并发

并行：就是两个任务同时运行(多个CPU)

并发：是指两个任务同时请求运行，而处理器一次只能接受一个任务，就会把两个任务安排轮流执行，由于CPU时间片运行时间较短，就会感觉两个任务在同时执行

2、线程的基本使用

static Thread currentThread() 返回对当前正在执行的线程对象的引用

Thread.currentThread().getName() //正在执行线程的，名字

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

class MyThread extends Thread{
    public void run(){
        //逻辑处理
    }
}
MyThread mt = new MyThread();
mt.start();

(2）实现Runnable接口，重写run方法(推荐使用)

class MyRunnable implements Runnable{
    public void run(){
        //逻辑处理
    }
}
MyRunnable mr = new MyRunnable();
Thread t = new Thread(mr);
t.start();

3、线程休眠

public static void sleep(long millis)

throws InterruptedException使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），释放CPU的时间片，具体取决于系统定时器和调度程序的精度和准确性。线程不会丢失任何显示器的所有权。

参数：
millis - 以毫秒为单位的睡眠时间长度
异常
IllegalArgumentException - 如果 millis值为负数
InterruptedException - 如果任何线程中断当前线程。当抛出此异常时，当前线程的中断状态将被清除。

public static void sleep(long millis,int nanos)

throws InterruptedException 毫秒，纳秒

            try {                                                                                
               Thread.sleep(500);                                            //线程休眠，在当前线程的执行中，暂停指定的毫秒数，释放CPU的时间片
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

Example：ThreadDemo1

/**
 * <p>
 * 线程的休眠
 * 在当前线程的执行中，暂停指定的毫秒数，释放CPU的时间片
 */
public class ThreadDemo1 {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        //推荐
        MyRunnable mr = new MyRunnable();
        Thread t2 = new Thread(mr);
        mt.start();//启动线程
        t2.start();
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "-" + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
/**
 * 实现线程的第一种方式：继承thread类
 */
class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (this.isInterrupted()) {
                break;
            }
            System.out.println(Thread.currentThread().getName() + "-" + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
                this.interrupt();
            }
        }
    }
}
/**
 * 实现线程的第二种方式：实现Runnable接口
 */
class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "-" + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

4、join与中断线程

join方法的主要作用是同步，它可以使得线程之间的并行执行变为串行执行，加入线程，让调用的线程先执行指定时间或执行完毕

public final void join() throws InterruptedException
等待这个线程死亡。
调用此方法的行为方式与调用完全相同
join (0)
异常 InterruptedException - 如果任何线程中断当前线程。当抛出此异常时，当前线程的中断状态将被清除。

public void interrupt()
中断这个线程。
除非当前线程中断自身，这是始终允许的

public static boolean interrupted()
测试当前线程是否中断。该方法可以清除线程的中断状态。换句话说，如果这个方法被连续调用两次，那么第二个调用将返回false（除非当前线程再次中断，在第一个调用已经清除其中断状态之后，在第二个调用之前已经检查过）。
忽略线程中断，因为线程在中断时不存在将被该方法返回false所反映。

自定义标记中断线程，推荐使用

Example：ThreadDemo2

/**
 * join方法：
 * 加入线程，让调用的线程先执行指定时间或执行完毕
 * 中断线程：
 * （1）使用interrupt方法来中断线程，设置一个中断状态（标记）
 * （2）自定义标记的方式(推荐使用)
 */
public class ThreadDemo2 {
    public static void main(String[] args){
        MyRunable2 mr2 = new MyRunable2();
        Thread t = new Thread(mr2);
//        t.start();
        MyRunable3 mr3 = new MyRunable3();
        Thread t2 = new Thread(mr3);
        t2.start();
        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName()+"--"+i);
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(i==20){
//                try {
//                    t.join();//让t线程执行完毕，再执行主线程
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//                t.interrupt();//中断线程,只是作了一个中断标记
                mr3.flag = false;
            }
        }
    }
}
class MyRunable2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            if(Thread.interrupted()){//测试中断状态，此方法会把中断状态清除
                //....保存数据处理
                break;
            }
            System.out.println(Thread.currentThread().getName()+"--"+i);
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
                Thread.currentThread().interrupt();
            }
        }
    }
}
class MyRunable3 implements Runnable{
    public boolean flag = true;
    public MyRunable3(){
        flag = true;
    }
    @Override
    public void run() {
        int i=0;
        while(flag){
            System.out.println(Thread.currentThread().getName()+"==="+(i++));
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

5、守护线程与yield

yield作用是暂停当前正在执行的线程对象（放弃当前的cpu资源），并执行其他线程。

yield是让当前运行线程回到可执行状态，以允许具有相同优先级的其他线程获得运行机会。

public final void setDaemon(boolean on)
将此线程标记为daemon线程或用户线程。当运行的唯一线程都是守护进程线程时， Java虚拟机将退出。

public final boolean isDaemon()
测试这个线程是否是守护线程。

public static void yield()
暂停当前正在执行的线程对象，并执行其他线程。（了解）

6、其他方法与优先级

方法名称	作用
long getId()	返回该线程的标识符
String getName()	返回该线程的名称
void setName(String name)	改变线程的名称，使之与参数name相同
boolean isAlive()	测试线程是否处于活动状态
void setPriority(int newPriority)	更改线程的优先级
static int MAX_PRIORITY	线程可以具有更高优先级
static int MIN_PRIORITY	线程可以具有更低优先级
static int NORM_PRIORITY	分配给线程的默认优先级

Example：ThreadDemo3

package com.vince;
import javax.sound.midi.Soundbank;
/**
 * Created by vince on 2017/6/2.
 */
public class ThreadDemo3 {
    public static void main(String[] args){
        MyRunnable4 mr4 = new MyRunnable4();
        Thread t = new Thread(mr4);
        t.setName("Thread-t");
        //优先级高可以提高该线程抢点CPU时间片的概率大
        t.setPriority(Thread.MAX_PRIORITY);
        //线程可以分成守护线程和 用户线程，当进程中没有用户线程时，JVM会退出
        t.setDaemon(true);//把线程设置为守护线程
        System.out.println(t.isAlive());
        t.start();
        System.out.println(t.isAlive());
        for (int i = 0; i < 50; i++) {
            System.out.println("main--"+i);
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (i==5){
                Thread.yield();//让出本次CPU执行时间片
            }
        }
    }
}
class MyRunnable4 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println("--"+i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

7、线程同步

线程同步是确保多线程共享数据的安全性，但同时会牺牲性能，同步过多还可能产生死锁，因此务必按需求使用同步。

1、多线程共享数据
在多线程的操作中，多个线程有可能同时处理同一个资源，这就是多线程中的共享数据。

2、线程同步
解决数据共享问题，必须使用同步，所谓同步就是指多个线程在同一个时间段内只能有一个线程执行指定代码，其他线程要等待此线程完成之后才可以继续执行。

线程进行同步，有以下三种方法：
（1）同步代码块
synchronized(要同步的对象){
要同步的操作 ;
}
（2）同步方法
public synchronized void method(){
要同步的操作 ;
}
（3） Lock（ReentrantLock）

3、同步准则
当编写 synchronized 块时，有几个简单的准则可以遵循，这些准则在避免死锁和性能危险的风险方面大有帮助：
（1）使代码块保持简短。把不随线程变化的预处理和后处理移出synchronized 块。
（2）不要阻塞。如InputStream.read()。
（3）在持有锁的时候，不要对其它对象调用方法

Example：ThreadDemo4

package com.vince;
import java.util.concurrent.locks.ReentrantLock;
/**
 * 1多线程共享数据时，会发生线程不安全的情况
 * 2多线程共享数据必须使用同步
 * 3实现同步的三种方法：
 * （1）使用同步代码块
 * （2）使用同步方法
 * （3）使用Lock（更灵活的代码控制）
 * 多线程共享数据，会有安全问题 ，使用同步可以解决安全问题 ，但同时会牺牲性能，所以同步的代码块要
 * 尽量保持简短，把不随数据变化的相关代码移除同步块，不要阻塞
 */
public class ThreadDemo4 {
    public static void main(String[] args) {
        MyRunnable5 mr5 = new MyRunnable5();
        Thread t1 = new Thread(mr5);
        Thread t2 = new Thread(mr5);
        t1.start();
        t2.start();
    }
}
class MyRunnable5 implements Runnable {
    private int ticket = 10;//售票
    //private Object obj = new Object();//同步锁
    @Override
    public void run() {
        for (int i = 0; i < 300; i++) {
//            if (ticket > 0) {
//                synchronized (this) {
//                    ticket--;
//                    try {
//                        Thread.sleep(1000);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
//                    System.out.println("您购买的票剩余" + ticket + "张");
//                }
//            }
            method2();
        }
    }
    //同步方法:同步的对象是当前对象(this)
    private synchronized void method() {
        if (ticket > 0) {
            ticket--;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("您购买的票剩余" + ticket + "张");
        }
    }
    //互斥锁
    ReentrantLock lock = new ReentrantLock();
    //Lock实现同步
    private void method2() {
        lock.lock();//锁
        try {
            if (ticket > 0) {
                ticket--;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("您购买的票剩余" + ticket + "张");
            }
        }finally {
            lock.unlock();//释放锁
        }
    }
}

8、死锁

过多的同步有可能出现死锁，死锁的操作一般是在程序运行的时候才有可能出现。

多线程中要进行资源的共享，就需要同步，但同步过多，就可能造成死锁。

package com.vince;
/**
 * Created by vince on 2017/6/5.
 * 线程死锁:在一个同步方法中调用了另一个对象的同步方法，可能产生死锁
 *
 */
public class DeadThreadDemo {
    public static void main(String[] args) {
        new DeadThread();
    }
}
//顾客
class Customer{
    public synchronized void say(Waiter w){
        System.out.println("顾客说：先吃饭再买单！");
        w.doService();
    }
    public synchronized void doService(){
        System.out.println("同意了,买完单再吃饭！");
    }
}
//服务员
class Waiter{
    public synchronized void say(Customer c){
        System.out.println("服务员说：先买单再吃饭！");
        c.doService();
    }
    public synchronized void doService(){
        System.out.println("同意了，吃完饭再买单！");
    }
}
//死锁线程
class DeadThread implements Runnable{
    Customer c = new Customer();
    Waiter w = new Waiter();
    public DeadThread(){
        new Thread(this).start();
        w.say(c);
    }
    @Override
    public void run() {
        c.say(w);
    }
}

9、生产者与消费者应用案例

多线程的开发中有一个最经典的操作案例，就是生产者-消费者，生产者不断生产产品，消费者不断取走产品。

例如：饭店里的有一个厨师和一个服务员，这个服务员必须等待厨师准备好膳食。当厨师准备好时，他会通知服务员，之后服务员上菜，然后返回继续等待。这是一个任务协作的示例，厨师代表生产者，而服务员代表消费者。

使用wait与notify

package com.vince;
/**
 * 两个线程协同工作，先生产，再消费
 * 面试题 ：
 * sleep 与 wait的区别？
 * sleep：让线程进入休眠状态，让出CPU的时间片，不释放对象监视器的所有权（对象锁）
 * wait：让线程进入等待状态，让出CPU的时间片，并释放对象监视器的所有权，等待其它线程通过notify方法来唤醒
 */
public class ProducterCustomerDemo {
    public static void main(String[] args) {
        Food food = new Food();
        Producter p = new Producter(food);
        Customers c = new Customers(food);
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);
        t1.start();
        t2.start();
    }
}
/**
 * 消费者
 */
class Customers implements Runnable{
    private Food food;
    public Customers(Food food){
        this.food = food;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            food.get();
        }
    }
}
/**
 * 生产者
 */
class Producter implements Runnable{
    private Food food;
    public Producter(Food food){
        this.food = food;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if(i%2==0){
                food.set("锅包肉","酸甜口味，爽");
            }else{
                food.set("佛跳墙","大补，滋阴补阳");
            }
        }
    }
}
/**
 * 食物
 */
class Food{
    private String name;
    private String desc;
    private boolean flag = true; //true表示可以生产，false表示可以消费
    /**
     * 生产产品
     */
    public synchronized void set(String name,String desc){
        //不能生产
        if(!flag){
            try {
                this.wait();//线程进入等待状态，释放监视器的所有权(对象锁)
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.setName(name);
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.setDesc(desc);
        flag = false;
        this.notify();//唤醒等待的线程（随机的其中一个）
    }
    /**
     * 消费产品
     */
    public synchronized void get(){
        //不能消费
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } 
        }
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(this.getName()+"->"+this.getDesc());
        flag = true;
        this.notify();
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getDesc() {
        return desc;
    }
    public void setDesc(String desc) {
        this.desc = desc;
    }
    @Override
    public String toString() {
        return "Food{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
    public Food(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
    public Food() {
    }
}

10、线程的生命周期

10、多线程与并发 - 图2

11、线程池

线程池是预先创建线程的一种技术。线程池在还没有任务到来之前，创建一定数量的线程，放入空闲队列中，然后对这些资源进行复用。减少频繁的创建和销毁对象。
jdk1.5版本以上提供了现成的线程池。
Java里面线程池的顶级接口是Executor，是一个执行线程的工具。
线程池接口是ExecutorService。

java.util.concurrent 包：并发编程中很常用的实用工具类
Executor 接口：执行已提交的 Runnable 任务的对象。
ExecutorService 接口：Executor 提供了管理终止的方法，以及可为跟踪一个或多个异步任务执行状况而生成Future 的方法。
Executors 类：此包中所定义的Executor、 ExecutorService等的工厂和实用方法。

在Executors类里面提供了一些静态工厂，生成一些常用的线程池。

newSingleThreadExecutor：创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

newFixedThreadPool：创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程

newCachedThreadPool：创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

newScheduledThreadPool：创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

Example：ThreadDemo5

package com.vince;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
 * JDK1.5线程池
 */
public class ThreadDemo5 {
    public static void main(String[] args) {
        //创建线程池(4种)
        //1、创建一个单线程的线程池
//        ExecutorService es = Executors.newSingleThreadExecutor();
        //2、创建一个固定大小的线程池
//        ExecutorService es = Executors.newFixedThreadPool(1);
        //3、创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，
        // 那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，
        // 此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，
        // 线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。
//        ExecutorService es = Executors.newCachedThreadPool();
        //4、创建一个大小无限的线程池。 此线程池支持定时以及周期性执行任务的需求。
        ScheduledExecutorService es = Executors.newScheduledThreadPool(3);
//        es.execute(new MyRunable6());
//        es.execute(new MyRunable6());
        es.schedule(new MyRunable6(),3000, TimeUnit.MILLISECONDS);
        es.shutdown();
    }
}
class MyRunable6 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"---"+i);
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}