线程之间通信
线程之间的通信？
多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。
为什么要处理线程间通信
多个线程并发执行时, 在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行, 那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。
如何保证线程间通信有效利用资源
多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。 就是多个线程在操作同一份数据时， 避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。
等待唤醒机制
这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争（race），比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制。就好比在公司里你和你的同事们，你们可能存在在晋升时的竞争，但更多时候你们更多是一起合作以完成某些任务。
就是在一个线程进行了规定操作后，就进入等待状态（wait()）， 等待其他线程执行完他们的指定代码过后 再将其唤醒（notify()）;在有多个线程进行等待时， 如果需要，可以使用 notifyAll()来唤醒所有的等待线程。
wait/notify 就是线程间的一种协作机制。
等待唤醒中的方法
方法名 说明
public final void wait() 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待
public final void notify() 唤醒在此对象监视器上等待的单个线程
public final void notifyAll() 唤醒在此对象监视器上等待的所有线程
wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知（notify）”在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中
notify：则选取所通知对象的 wait set 中的一个线程释放；例如，餐馆有空位置后，等候就餐最久的顾客最先入座。
notifyAll：则释放所通知对象的 wait set 上的全部线程。
注意事项
哪怕只通知了一个等待的线程，被通知线程也不能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以她需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调用 wait 方法之后的地方恢复执行。
总结如下：
如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE 状态；
否则，从 wait set 出来，又进入 entry set，线程就从 WAITING 状态又变成 BLOCKED 状态
wait和notify方法需要注意的细节
wait方法与notify方法必须要由同一个锁对象调用
因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
wait方法与notify方法是属于Object类的方法的
因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
wait方法与notify方法必须要在同步代码块或者是同步函数中使用
因为：必须要通过锁对象调用这2个方法
生产者与消费者问题
等待唤醒机制其实就是经典的“生产者与消费者”的问题。
就拿生产包子消费包子来说等待唤醒机制如何有效利用资源：
包子铺线程生产包子，吃货线程消费包子。当包子没有时（包子状态为false），吃货线程等待，包子铺线程生产包子（即包子状态为true），并通知吃货线程（解除吃货的等待状态）,因为已经有包子了，那么包子铺线程进入等待状态。接下来，吃货线程能否进一步执行则取决于锁的获取情况。如果吃货获取到锁，那么就执行吃包子动作，包子吃完（包子状态为false），并通知包子铺线程（解除包子铺的等待状态）,吃货线程进入等待。包子铺线程能否进一步执行则取决于锁的获取情况。
代码演示
public class Baozi {
private String pier;
private String xianer;
boolean flag = false;
public Baozi() {
}
public Baozi(String pier, String xianer, boolean flag) {
this.pier = pier;
this.xianer = xianer;
this.flag = flag;
}
public String getPier() {
return pier;
}
public void setPier(String pier) {
this.pier = pier;
}
public String getXianer() {
return xianer;
}
public void setXianer(String xianer) {
this.xianer = xianer;
}
public boolean isFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
@Override
public String toString() {
return "Baozi{" +
"pier='" + pier + '\'' +
", xianer='" + xianer + '\'' +
", flag=" + flag +
'}';
}
}
public class Boss extends Thread{
int count = 0;
private Baozi baozi;
public Boss(String name, Baozi baozi) {
super(name);
this.baozi = baozi;
}
@Override
public void run() {
while (true){
synchronized (baozi){
if (baozi.flag == true){
try {
baozi.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("包子铺开始做包子");
if (count%2 == 0){
baozi.setPier("薄皮");
baozi.setXianer("猪肉大葱");
}else {
baozi.setPier("厚皮");
baozi.setXianer("虾仁");
}
count++;
baozi.flag = true;
System.out.println("包子造好了："+baozi.getPier()+baozi.getXianer());
System.out.println("吃货来吃吧");
baozi.notify();
}
}
}
}
public class Customer extends Thread{
private Baozi baozi;
public Customer(String name, Baozi baozi) {
super(name);
this.baozi = baozi;
}
@Override
public void run() {
while (true){
synchronized (baozi){
if (baozi.flag == false){
try {
baozi.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("吃货正在吃"+baozi.getPier()+baozi.getXianer()+"包子");
baozi.flag = false;
baozi.notify();
}
}
}
}
public class BaoZiTest {
public static void main(String[] args) {
Baozi baozi = new Baozi();
Customer c = new Customer("吃货", baozi);
Boss b = new Boss("包子铺", baozi);
c.start();
b.start();
}
}
线程池
我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：
如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。
那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？
概念
概念:其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。
好处
合理利用线程池能够带来三个好处
降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。
方法
Java里面线程池的顶级接口是java.util.concurrent.Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是java.util.concurrent.ExecutorService。
要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在java.util.concurrent.Executors线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官方建议使用Executors工程类来创建线程池对象。
Executors类中有个创建线程池的方法如下：
方法名 描述
public static ExecutorService newFixedThreadPool(int nThreads) 返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)
使用步骤
1. 创建线程池对象。
2. 创建Runnable接口子类对象。(task)
3. 提交Runnable接口子类对象。(take task)
4. 关闭线程池(一般不做)。
代码演示
public class MyRunnable implements Runnable {
public MyRunnable() {
}
@Override
public void run() {
System.out.println("我要一个女朋友");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("女朋友来了："+Thread.currentThread().getName());
System.out.println("女朋友来了，玩了一下，又走了");
}
}
public class ThreadPollTest {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(2);
MyRunnable myRunnable = new MyRunnable();
executorService.submit(myRunnable);
executorService.submit(myRunnable);
executorService.submit(myRunnable);
}
}voliate关键字
volatile保证线程间变量的可见性，简单地说就是当线程A对变量X进行了修改后，在线程A后面执行的其他线程能看到变量X的变动，更详细地说是要符合以下两个规则：
线程对变量进行修改之后，要立刻回写到主内存。
线程对变量读取的时候，要从主内存中读，而不是缓存
各线程的工作内存间彼此独立、互不可见，在线程启动的时候，虚拟机为每个内存分配一块工作内存，不仅包含了线程内部定义的局部变量，也包含了线程所需要使用的共享变量(非线程内构造的对象)的副本，即为了提高执行效率。
volatile是不错的机制，但是volatile不能保证原子性。
/**
* volatile用于保证数据的同步，也就是可见性
*/
public class VolatileTest {
private volatile static int num = 0;
public static void main(String[] args) throws InterruptedException {
new Thread(
new Runnable(){
public void run(){
while(num==0) { //此处不要编写代码
}
}
}
) .start();
Thread.sleep(1000);
num = 1;
}
}单例设计模式
特点
1、单例类只能有一个实例。也就是只有一个对象
2、单例类必须自己创建自己的唯一实例。 写单例构造方法是要私有的
3、单例类必须给所有其他对象提供这一实例。 在该方法中，提供一个方法，用于获取该对象
前提条件
私有构造方法
在本类的成员位置,创建出自己类对象
提供公共方法,返回创建的对象 ，该方法必须是静态的
代码演示
public class Single {
/**
* 饿汉模式
*/
private Single(){}
private static final Single s = new Single();
public static Single getInstance() {
return s;
}
}
public class Single {
/**
* 单例模式懒汉式是一种对象延迟加载，在多线程情况下会有安全隐患,
* 要想解决此问题,我们需要加同步代码块,进行解决
*/
private Single(){}
private static Single s = null;
public static Single getInstance(){
if (s == null){
synchronized (Single.class) {
if (s == null) {
s = new Single();
}
}
}
return s;
}
/**
* 双层if判断的原因
*
* - 方法中加入同步锁，保证线程安全
* - 第二个线程调用方法getInstance()的时候，变量s，已经不是null，被前面的线程new过
* - 当已经有对象了，第二个线程没有必要再进入同步了，直接return返回对象即可
*/
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
