多线程技术五(线程并发协作)

目录

线程并发协作

线程并发协作总结：

任务定时调度

java.util.Timer

java.util.TimerTask

---

线程并发协作

        多线程环境下，我们经常需要多个线程的并发和协作。这个时候，就需要了解一个重要 的多线程并发协作模型“生产者—消费者模式”。

• 什么是生产者？
  生产者指的是负责生产数据的模块（这里模块可能是：方法、对象、线程、进程）。
• 什么是消费者？
  消费者指的是负责处理数据的模块（这里模块可能是：方法、对象、线程、进程）。
• 什么是缓冲区？
  消费者不能直接使用生产者的数据，它们之间有个“缓冲区”。生产者将生产好的数据放 入“缓冲区”，消费者从“缓冲区”拿要处理的数据。

缓冲区是实现并发的核心，缓冲区的设置有 3 个好处：

1. 实现线程的并发协作
   有了缓冲区以后，生产者线程只需要往缓冲区里面放置数据，而不需要管消费者消费的 情况；同样，消费者只需要从缓冲区拿数据处理即可，也不需要管生产者生产的情况。 这样，就从逻辑上实现了“生产者线程”和“消费者线程”的分离。
2. 解耦了生产者和消费者
   生产者不需要和消费者直接打交道。
3. 解决忙闲不均，提高效率
   生产者生产数据慢时，缓冲区仍有数据，不影响消费者消费；消费者处理数据慢时，生 产者仍然可以继续往缓冲区里面放置数据 。

生产者与消费者模式

public class TestProduce {
    public static void main(String[ ] args) {
        SyncStack sStack = new SyncStack();// 定义缓冲区对象；
        Shengchan sc = new Shengchan(sStack);// 定义生产线程；
        Xiaofei xf = new Xiaofei(sStack);// 定义消费线程；
        sc.start();
        xf.start();
    }
}
class Mantou {// 馒头
    int id;
    Mantou(int id) {
        this.id = id;
    }
}
class SyncStack {// 缓冲区(相当于：馒头筐)
    int index = 0;
    Mantou[ ] ms = new Mantou[10];
    public synchronized void push(Mantou m) {
        while (index == ms.length) {//说明馒头筐满了
            try {
                //wait后，线程会将持有的锁释放，进入阻塞状态；
                //这样其它需要锁的线程就可以获得锁；
                this.wait();
                //这里的含义是执行此方法的线程暂停，进入阻塞状态，
                //等消费者消费了馒头后再生产。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 唤醒在当前对象等待池中等待的第一个线程。
        //notifyAll叫醒所有在当前对象等待池中等待的所有线程。
        this.notify();
        // 如果不唤醒的话。以后这两个线程都会进入等待线程，没有人唤醒。
        ms[index] = m;
        index++;
    }
    public synchronized Mantou pop() {
        while (index == 0) {//如果馒头筐是空的；
            try {
                //如果馒头筐是空的，就暂停此消费线程（因为没什么可消费的嘛）。
                this.wait(); //等生产线程生产完再来消费；
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        index--;
        return ms[index];
    }
}
class Shengchan extends Thread {// 生产者线程
    SyncStack ss = null;
    public Shengchan(SyncStack ss) {
        this.ss = ss;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("生产馒头：" + i);
            Mantou m = new Mantou(i);
            ss.push(m);
        }
    }
}
class Xiaofei extends Thread {// 消费者线程；
    SyncStack ss = null;
    public Xiaofei(SyncStack ss) {
        this.ss = ss;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            Mantou m = ss.pop();
            System.out.println("消费馒头：" + i);
        }
    }
}

线程并发协作总结：

线程并发协作（也叫线程通信），通常用于生产者—消费者模式，情景如下：

1. 生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条 件。
2. 对于生产者，没有生产产品之前，消费者要进入等待状态。而生产了产品之后， 又需要马上通知消费者消费。
3. 对于消费者，在消费之后，要通知生产者已经消费结束，需要继续生产新产品 以供消费。
4. 在生产者消费者问题中，仅有 synchronized 是不够的。
   1. synchronized 可阻止并发更新同一个共享资源，实现了同步；
   2. synchronized 不能用来实现不同线程之间的消息传递（通信）。
5. 那线程是通过哪些方法来进行消息传递（通信）的呢？见如下总结：

线程通信常用方法

方法名	作 用
final void wait()	表示线程一直等待，直到得到其它线程通知
void wait(long timeout)	线程等待指定毫秒参数的时间
final void wait(long timeout,int nanos)	线程等待指定毫秒、微秒的时间
final void notify()	唤醒一个处于等待状态的线程
final void notifyAll()	唤醒同一个对象上所有调用 wait()方法的线程，优 先级别高的线程优先运行

        以上方法均是 java.lang.Object 类的方法； 都只能在同步方法或者同步代码块中使用，否则会抛出异常。

任务定时调度

任务定时调度，在项目开发中也经常用到。比如：

1. 我们需要每天晚上 12:00 启动数据备份功能。
2. 如家连锁酒店每天 23:45 停止所有收支服务，统一开始启动核算程序进行全公司当日 财务核算。

        当然，在实际项目开发中我们会使用 quanz 任务框架方便开发。但我们也可以使用本节 的 Timer 和 Timertask 类实现同样的功能。

        通过 Timer 和 Timetask，我们可以实现定时启动某个线程，通过线程定时执行某个任务。

java.util.Timer

        在这种实现方式中，Timer 类作用是类似闹钟的功能，也就是定时或者每隔一定时间触 发一次线程。其实，Timer 类本身实现的就是一个线程，只是这个线程是用来实现调用其它 线程的。

java.util.TimerTask

        TimerTask 类是一个抽象类，该类实现了 Runnable 接口，所以该类具备多线程的能力。

        在这种实现方式中，通过继承 TimerTask 使该类获得多线程的能力，将需要多线程执行 的代码书写在 run 方法内部，然后通过 Timer 类启动线程的执行。

java.util.Timer 的使用

import java.util.Timer;
import java.util.TimerTask;

public class TestTimer {
    public static void main(String[ ] args) {
        Timer t1 = new Timer();//定义计时器；
        MyTask task1 = new MyTask();//定义任务；
        t1.schedule(task1,3000); //3秒后执行；
        //t1.schedule(task1,5000,1000);//5秒以后每隔1秒执行一次！
        //GregorianCalendar calendar1 = new GregorianCalendar(2010,0,5,14,36,57);
        //t1.schedule(task1,calendar1.getTime()); //指定时间定时执行；
    }
}
class MyTask extends TimerTask {//自定义线程类继承TimerTask类；
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println("任务1:"+i);
        }
    }
}

        运行以上程序时，可以感觉到在输出之前有明显的延迟。在实际使用时，一个 Timer 可以启动任意多个 TimerTask 实现的线程，但是多个线程之 间会存在阻塞。所以如果多个线程之间需要完全独立的话，最好还是一个 Timer 启动一个 TimerTask 实现。

        实际开发中，我们可以使用开源框架 quanz，更加方便的实现任务定时调度。实际上，quanz 底层原理就是我们这里介绍的内容。