Java学习4-5_线程

多线程

一、概念

1.1 线程与进程

• 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间
• 线程：
  1. 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行，一个进程最少有一个线程
  2. 线程实际上是在进程基础上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程

1.2 线程调度

• 分时调度：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
• 抢占式调度：
  1. 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的是抢占式调度
  2. CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言，某个时刻， 只能执行一个线程，而 CPU 的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

1.3 同步与异步

• 同步：排队执行，效率低但是安全
• 异步：同时执行，效率高但是数据不安全

1.4 并发与并行

• 并发：指两个或多个事件在同一个时间段内发生
• 并行：指两个或多个事件在同一时刻发生（同时发生）。

二、多线程使用

2.1 继承Thread类

/**
 * 继承Thread类，重写run方法
 * @author ShiYu
 *
 */
public class MyThread extends Thread{
    
    
	@Override
	public void run() {
    
    
		// TODO Auto-generated method stub
	}
}

//使用自己的线程类
class MainTest {
    
    
	public static void main(String[] args) {
    
    
		MyThread th = new MyThread();
		th.start();
	}
}

2.2 实现 Runnable

/**
 * 实现Runnable，重写run方法
 * 与继承Thread相比：
 * 1.通过创建任务然后给线程分配的方式来实现，更加适合多个线程同时执行相同任务的情况
 * 2.避免单继承带来的局限性
 * 3.任务与线程本身是分离的，提高了程序的健壮性
 * 4.线程池只接受Runnable类型的任务，不接受Thread类型的线程
 * @author ShiYu
 *
 */
public class MyRunnable implements Runnable{
    
    
	@Override
	public void run() {
    
    
		// TODO Auto-generated method stub
	}
	
}

class MainTest {
    
    
	public static void main(String[] args) {
    
    
		MyRunnable r = new MyRunnable();//相当于创建了一个任务，然后将这个任务交给Thread运行
		Thread th = new Thread(r);
		th.start();
	}
}

2.3 Thread 类

方法	描述
start()	启动一个线程，当调用start方法后，系统才会开启一个新的线程来执行用户定义的子任务，在这个过程中，会为相应的线程分配需要的资源。
run()	不需要用户来调用，当通过start方法启动一个线程之后，当线程获得了CPU执行时间，便进入run方法体去执行具体的任务。注意，继承Thread类必须重写run方法，在run方法中定义具体要执行的任务。
sleep()	sleep相当于让线程睡眠，交出CPU，让CPU去执行其他的任务。sleep方法不会释放锁，也就是说如果当前线程持有对某个对象的锁，则即使调用sleep方法，其他线程也无法访问这个对象。
yield()	让当前线程交出CPU权限，让CPU去执行其他的线程。它跟sleep方法类似，同样不会释放锁。但是yield不能控制具体的交出CPU的时间，另外，yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。yield方法并不会让线程进入阻塞状态，而是让线程重回就绪状态，它只需要等待重新获取CPU执行时间，这一点是和sleep方法不一样的。
join()	假如在main线程中，调用thread.join方法，则main方法会等待thread线程执行完毕或者等待一定的时间。如果调用的是无参join方法，则等待thread执行完毕，如果调用的是指定了时间参数的join方法，则等待一定的事件。
wait()	方法会让线程进入阻塞状态，并且会释放线程占有的锁，并交出CPU执行权限。由于wait方法会让线程释放对象锁，所以join方法同样会让线程释放对一个对象持有的锁。具体的wait方法使用在后面文章中给出。
interrupt()	单独调用interrupt方法可以使得处于阻塞状态的线程抛出一个异常，也就说，它可以用来中断一个正处于阻塞状态的线程；另外，通过interrupt方法和isInterrupted()方法来停止正在运行的线程。
isInterrupted()	判断线程是否被中断
stop()	废弃
destroy()	废弃
getId()	获取线程id
getName()/setName()	获取或者设置线程名称。
getPriority()/setPriority()	获取和设置线程优先级
setDaemon()/isDaemon()	用来设置线程是否成为守护线程和判断线程是否是守护线程。
currentThread()	获取当前线程。

2.4 其他

1. 线程阻塞：也就是耗时操作比如文件读取，网络数据

2. 线程中断：给线程发送一个中断标记，但是该线程是否死亡是由他自身来决定

3. 守护线程

   • 线程分为用户线程和守护线程

   • 用户线程：当一个进程不包含任何存活的用户线程时就结束

   • 守护线程：守护用户线程，当最后一个用户线程结束时，所有守护线程自动死亡

三、线程安全

3.1 线程不安全

多个线程在同时运行操作同一个数据时时会发生线程不安全的问题

public class Demo7 {
    
    
    public static void main(String[] args) {
    
    
        //线程不安全
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
    
    
        //总票数
        private int count = 10;
        @Override
        public void run() {
    
    
            while (count>0){
    
    
                System.out.println("正在准备卖票");
                try {
    
    
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
                count--;
                System.out.println("卖票结束,余票："+count);
            }
        }
    }
}

出现负数，时间片混乱

3.2内置锁(synchronized)和显式锁ReentrantLock

jdk6 对synchronize加入了很多优化措施，有自适应自旋，锁消除，锁粗化，轻量级锁，偏向锁等等。

// synchronized关键字用法示例
public synchronized void add(int t){
    
    // 同步方法
  this.v += t;
}
  
public static synchronized void sub(int t){
    
    // 同步静态方法
  value -= t;
}
public int decrementAndGet(){
    
    
  synchronized(obj){
    
    // 同步代码块
    return --v;
  }
}

1. 当synchronized作用于普通方法是，锁对象是this
2. 当synchronized作用于静态方法是，锁对象是当前类的Class对象；
3. 当synchronized作用于代码块时，锁对象是synchronized(obj)中的这个obj。

3.2.1 内置锁和显式锁的区别

可定时：RenentrantLock.tryLock(long timeout, TimeUnit unit)提供了一种以定时结束等待的方式，如果线程在指定的时间内没有获得锁，该方法就会返回false并结束线程等待。

可中断：你一定见过InterruptedException，很多跟多线程相关的方法会抛出该异常，这个异常并不是一个缺陷导致的负担，而是一种必须，或者说是一件好事。可中断性给我们提供了一种让线程提前结束的方式（而不是非得等到线程执行结束），这对于要取消耗时的任务非常有用。对于内置锁，线程拿不到内置锁就会一直等待，除了获取锁没有其他办法能够让其结束等待。RenentrantLock.lockInterruptibly()给我们提供了一种以中断结束等待的方式。

条件队列(condition queue)：线程在获取锁之后，可能会由于等待某个条件发生而进入等待状态（内置锁通过Object.wait()方法，显式锁通过Condition.await()方法），进入等待状态的线程会挂起并自动释放锁，这些线程会被放入到条件队列当中。synchronized对应的只有一个条件队列，而ReentrantLock可以有多个条件队列，多个队列有什么好处呢？请往下看。

条件谓词：线程在获取锁之后，有时候还需要等待某个条件满足才能做事情，比如生产者需要等到“缓存不满”才能往队列里放入消息，而消费者需要等到“缓存非空”才能从队列里取出消息。这些条件被称作条件谓词，线程需要先获取锁，然后判断条件谓词是否满足，如果不满足就不往下执行，相应的线程就会放弃执行权并自动释放锁。使用同一把锁的不同的线程可能有不同的条件谓词，如果只有一个条件队列，当某个条件谓词满足时就无法判断该唤醒条件队列里的哪一个线程；但是如果每个条件谓词都有一个单独的条件队列，当某个条件满足时我们就知道应该唤醒对应队列上的线程（内置锁通过Object.notify()或者Object.notifyAll()方法唤醒，显式锁通过Condition.signal()或者Condition.signalAll()方法唤醒）。这就是多个条件队列的好处。

使用内置锁时，对象本身既是一把锁又是一个条件队列；使用显式锁时，RenentrantLock的对象是锁，条件队列通过RenentrantLock.newCondition()方法获取，多次调用该方法可以得到多个条件队列。

用途比较

基本语法上，ReentrantLock与synchronized很相似，它们都具备一样的线程重入特性，只是代码写法上有点区别而已，一个表现为API层面的互斥锁（Lock），一个表现为原生语法（JVM）层面的互斥锁（synchronized）。ReentrantLock相对synchronized而言还是增加了一些高级功能，主要有以下三项：

1、等待可中断：当持有锁的线程长期不释放锁时，正在等待的线程可以选择放弃等待，改为处理其他事情，它对处理执行时间非常上的同步块很有帮助。而在等待由synchronized产生的互斥锁时，会一直阻塞，是不能被中断的。

2、可实现公平锁：多个线程在等待同一个锁时，必须按照申请锁的时间顺序排队等待，而非公平锁则不保证这点，在锁释放时，任何一个等待锁的线程都有机会获得锁。synchronized中的锁是非公平锁，ReentrantLock默认情况下也是非公平锁，但可以通过构造方法ReentrantLock（ture）来要求使用公平锁。

3、锁可以绑定多个条件：ReentrantLock对象可以同时绑定多个Condition对象（名曰：条件变量或条件队列），而在synchronized中，锁对象的wait() 和notify() 或notifyAll()方法可以实现一个隐含条件，但如果要和多于一个的条件关联的时候，就不得不额外地添加一个锁，而ReentrantLock则无需这么做，只需要多次调用newCondition() 方法即可。而且我们还可以通过绑定Condition对象来判断当前线程通知的是哪些线程（即与Condition对象绑定在一起的其他线程）。

3.3 同步代码块

格式：synchronized(锁对象) { }

当线程开始执行同步代码块前，必须先获得对同步代码块的锁定。并且任何时刻只能有一个线程可以获得对同步监视器的锁定，当同步代码块执行完成后，该线程会释放对该同步监视器的锁定。

static class Ticket implements Runnable {
    
    
	// 总票数
	private int count = 10;
	private Object o = new Object();//锁必须是外部的同一把锁才能锁住

	@Override
	public void run() {
    
    
		Object o = new Object(); // 这里不是同一把锁，所以锁不住
		while (true) {
    
    
            synchronized (o) {
    
    
                if (count > 0) {
    
    
                    // 卖票
                    System.out.println("正在准备卖票");
                    try {
    
    
                    	Thread.sleep(1000);
                    } catch (InterruptedException e) {
    
    
                    	e.printStackTrace();
                    }
                    count--;
                    System.out.println(Thread.currentThread().getName() + "卖票结束,余票：" + count);
				} else {
    
    
					break;
				}
			}
		}
	}
}

3.4 同步方法

以方法为单位进行加锁

public synchronized boolean sale() {
    
    
    if (count > 0) {
    
    
        //卖票
        System.out.println("正在准备卖票");
        try {
    
    
            Thread.sleep(1000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        count--;
        System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
        return true;
    }
        return false;
}

3.5 显式锁

static class Ticket implements Runnable{
    
    
    //总票数
    private int count = 10;
    //参数为true表示公平锁    默认是false 不是公平锁
    private Lock l = new ReentrantLock(true);
    @Override
    public void run() {
    
    
        while (true) {
    
    
            l.lock();
                if (count > 0) {
    
    
                    //卖票
                    System.out.println("正在准备卖票");
                    try {
    
    
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
    
    
                        e.printStackTrace();
                    }
                    count--;
                    System.out.println(Thread.currentThread().getName()+"卖票结束,余票：" + count);
                }else {
    
    
                    break;
                }
                l.unlock();
        }
    }
}

3.6 线程死锁

线程互相等待对方，形成死锁

3.7 生产者与消费者

生产者是一堆线程，消费者是另一堆线程，内存缓冲区可以使用List数组队列，数据类型只需要定义一个简单的类就好。关键是如何处理多线程之间的协作。这其实也是多线程通信的一个范例。

在这个模型中，最关键就是内存缓冲区为空的时候消费者必须等待，而内存缓冲区满的时候，生产者必须等待。其他时候可以是个动态平衡。值得注意的是多线程对临界区资源的操作时候必须保证在读写中只能存在一个线程，所以需要设计锁的策略。

public class Demo4  {
    
    

    /**
     * 多线程通信问题, 生产者与消费者问题
     * @param args
     */
    public static void main(String[] args) {
    
    
        Food f = new Food();
        new Cook(f).start();
        new Waiter(f).start();
    }

    //厨师
    static class Cook extends Thread{
    
    
        private Food f;
        public Cook(Food f) {
    
    
            this.f = f;
        }

        @Override
        public void run() {
    
    
            for(int i=0;i<100;i++){
    
    
                if(i%2==0){
    
    
                    f.setNameAndSaste("老干妈小米粥","香辣味");
                }else{
    
    
                    f.setNameAndSaste("煎饼果子","甜辣味");
                }
            }
        }
    }
    //服务生
    static class Waiter extends Thread{
    
    
        private Food f;
        public Waiter(Food f) {
    
    
            this.f = f;
        }
        @Override
        public void run() {
    
    
            for(int i=0;i<100;i++){
    
    
                try {
    
    
                    Thread.sleep(100);
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
                f.get();
            }
        }
    }
    //食物
    static class Food{
    
    
        private String name;
        private String taste;

        //true 表示可以生产
        private boolean flag = true;

        public synchronized void setNameAndSaste(String name,String taste){
    
    
            if(flag) {
    
    
                this.name = name;
                try {
    
    
                    Thread.sleep(100);
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
                this.taste = taste;
                flag = false;
                this.notifyAll();
                try {
    
    
                    this.wait();
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
            }
        }
        public synchronized void get(){
    
    
            if(!flag) {
    
    
                System.out.println("服务员端走的菜的名称是:" + name + ",味道:" + taste);
                flag = true;
                this.notifyAll();
                try {
    
    
                    this.wait();
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
            }
        }
    }
}

3.8 线程的状态

1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
3. 阻塞(BLOCKED)： 表示线程阻塞于锁。
4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
5. 超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。
6. 终止(TERMINATED)：表示该线程已经执行完毕。

3.9 第三种实现线程的方法

Runnable接口与Callable接口对比

//Callable接口
public interface Callable<V> {
    
    
	V call() throws Exception;
}
//Runnable接口
public interface Runnable {
    
    
	public abstract void run();
}

3.9.1 Callable接口使用

//1. 编写类实现Callable接口 , 实现call方法
class XXX implements Callable<T> {
    
    
    @Override
    public <T> call() throws Exception {
    
    
    	return T;
    }
}
//2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象
FutureTask<Integer> future = new FutureTask<>(callable);
//3. 通过Thread,启动线程
new Thread(future).start();

3.9.2 Runnable 与 Callable的相同点

• 都是接口
• 都可以编写多线程程序
• 都采用Thread.start()启动线程

3.9.3 Runnable 与 Callable的不同点

• Runnable没有返回值；Callable可以返回执行结果
• Callable接口的call()允许抛出异常；Runnable的run()不能抛出

3.9.4 Callable获取返回值

Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执 行，如果不调用不会阻塞。

四、线程池

4.1 线程池概述

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

4.1.1 线程池优势

1. 降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗；
2. 提高系统响应速度，当有任务到达时，通过复用已存在的线程，无需等待新线程的创建便能立即执行；
3. 方便线程并发数的管控。因为线程若是无限制的创建，可能会导致内存占用过多而产生OOM，并且会造成cpu过度切换；
4. 供更强大的功能，延时定时线程池。

4.2 缓存线程池

newCachedThreadPool 可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

/**
* 缓存线程池. (长度无限制) 执行流程: 
* 1.判断线程池是否存在空闲线程
* 2.存在则使用
* 3.不存在,则创建线程 并放入线程池, 然后使用
*/
ExecutorService service = Executors.newCachedThreadPool();
// 向线程池中 加入 新的任务
service.execute(new Runnable() {
    
    
	@Override
	public void run() {
    
    
		System.out.println("线程的名称:" + Thread.currentThread().getName());
	}
});
service.execute(new Runnable() {
    
    
	@Override
	public void run() {
    
    
		System.out.println("线程的名称:" + Thread.currentThread().getName());
	}
});
service.execute(new Runnable() {
    
    
	@Override
	public void run() {
    
    
		System.out.println("线程的名称:" + Thread.currentThread().getName());
	}
});

4.3 定长线程池

newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

/**
* 定长线程池. (长度是指定的数值) 执行流程: 
* 1.判断线程池是否存在空闲线程
* 2.存在则使用
* 3.不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
* 4.不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
*/
ExecutorService service = Executors.newFixedThreadPool(2);
service.execute(new Runnable() {
    
    
	@Override
	public void run() {
    
    
		System.out.println("线程的名称:" + Thread.currentThread().getName());
	}
});
service.execute(new Runnable() {
    
    
	@Override
	public void run() {
    
    
		System.out.println("线程的名称:" + Thread.currentThread().getName());
	}
});

4.4 单线程线程池

newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

/**
* 单线程线程池.执行流程:
* 1.判断线程池的那个线程是否空闲
* 2.空闲则使用
* 4.不空闲,则等待 池中的单个线程空闲后使用
*/
ExecutorService service = Executors.newSingleThreadExecutor();
service.execute(new Runnable() {
    
    
	@Override
	public void run() {
    
    
		System.out.println("线程的名称:" + Thread.currentThread().getName());
	}
});
service.execute(new Runnable() {
    
    
	@Override
	public void run() {
    
    
		System.out.println("线程的名称:" + Thread.currentThread().getName());
	}
});

4.5 周期定长线程池

/**
* 周期任务 定长线程池. 执行流程:
* 1.判断线程池是否存在空闲线程
* 2.存在则使用
* 3.不存在空闲线程,且线程池未满的情况下,则创建线程并放入线程池, 然后使用
* 4.不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
*
* 周期性任务执行时: 定时执行, 当某个时机触发时, 自动执行某任务 .
*/
ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
/**
* 定时执行 参数 1.runnable类型的任务参数 2.时长数字 参数 3.时长数字的单位
*/
/*
* service.schedule(new Runnable() {
* 
* @Override public void run() { System.out.println("俩人相视一笑~ 嘿嘿嘿"); }
* },5,TimeUnit.SECONDS);
*/
/**
* 周期执行参数 1.runnable类型的任务参数 2.时长数字(延迟执行的时长)参数 3.周期时长(每次执行的间隔时间)参数 4.时长数字的单位
*/
service.scheduleAtFixedRate(new Runnable() {
    
    
	@Override
	public void run() {
    
    
		System.out.println("俩人相视一笑~ 嘿嘿嘿");
	}
}, 5, 2, TimeUnit.SECONDS);