通常同步意味着一个任务的某个处理过程会对多个线程在用串行化处理，而异步则意味着某个处理过程可以允许多个线程同时处理。异步通常代表着更好的性能，因为它很大程度上依赖于缓冲，是典型的使用空间换时间的做法，例如在计算机当中，高速缓存作为cpu和磁盘io之间的缓冲地带协调cpu高速计算能力和磁盘的低速读写能力。
十余年的大埔网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。营销型网站建设的优势是能够根据用户设备显示端的尺寸不同，自动调整大埔建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。成都创新互联从事“大埔网站设计”,“大埔网站推广”以来，每个客户项目都认真落实执行。
（1）：重新启动一个java程序就启动了一个进程
可以用操作系统命令行启动 Runtime.getRuntime().exec("java -classpath . XXX");
（2）：可不可以在接收消息的模块中的addtolist函数中添加一个专门的处理函数，函数执行时先向list中添加消息，然后探测当前有没有处理线程，如果没有，则启动线程。
（3）：想省点工作，可以用BlockingQueue来代替list，这样线程等待和唤醒不用写代码实现了，如果非要用list，那么就做好同步
list的小例子：
Java codeclass MessageConsumer extends Thead { private ListYourMessageType list; private boolean running = true; public MessageConsumer(ListYourMessageType list) {this.list = list;} public void run() { while (running) { YourMessageType msg = null; try { synchronized(list) { while (list.size() == 0) { list.wait(); } msg = list.remove(0); list.notiryAll(); } } catch (Exception e) { e.printStackTrace(); } if (msg == null) continue; //System.out.println(msg); //print message } }}//调用sampleclass ShareModule { ListYourMessageType list = new ArrayListYourMessageType(); ...}public class Main { public static void main(String[] args) { ShareMudule sm; //so on ... Thread t = new MessageConsumer(sm.list); t.start(); ... }}
1. 使用wait和notify方法
这个方法其实是利用了锁机制，直接贴代码:
public class Demo1 extends BaseDemo{ private final Object lock = new Object(); @Override public void callback(long response) { System.out.println("得到结果"); System.out.println(response); System.out.println("调用结束"); synchronized (lock) { lock.notifyAll(); } } public static void main(String[] args) { Demo1 demo1 = new Demo1(); demo1.call(); synchronized (demo1.lock){ try { demo1.lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("主线程内容"); } }
可以看到在发起调用后，主线程利用wait进行阻塞，等待回调中调用notify或者notifyAll方法来进行唤醒。注意，和大家认知的一样，这里wait和notify都是需要先获得对象的锁的。在主线程中最后我们打印了一个内容，这也是用来验证实验结果的，如果没有wait和notify，主线程内容会紧随调用内容立刻打印;而像我们上面的代码，主线程内容会一直等待回调函数调用结束才会进行打印。
没有使用同步操作的情况下，打印结果:发起调用 调用返回 主线程内容 得到结果 1 调用结束
而使用了同步操作后:
发起调用 调用返回 得到结果 9 调用结束 主线程内容2. 使用条件锁
和方法一的原理类似:
public class Demo2 extends BaseDemo { private final Lock lock = new ReentrantLock(); private final Condition con = lock.newCondition(); @Override public void callback(long response) { System.out.println("得到结果"); System.out.println(response); System.out.println("调用结束"); lock.lock(); try { con.signal(); }finally { lock.unlock(); } } public static void main(String[] args) { Demo2 demo2 = new Demo2(); demo2.call(); demo2.lock.lock(); try { demo2.con.await(); } catch (InterruptedException e) { e.printStackTrace(); }finally { demo2.lock.unlock(); } System.out.println("主线程内容"); } }
基本上和方法一没什么区别，只是这里使用了条件锁，两者的锁机制有所不同。
在整个思路上要调整一下
1、会有很多线程给一个队列上添加任务
2、有一个或者多个线程逐个执行队列的任务
考虑一下几点：
1、没有任务时，队列执行线程处于等待状态
2、添加任务时，激活队列执行线程，全部run起来，首先抢到任务的执行，其他全部wait
给个小例子吧
package org;
import java.util.LinkedList;
import java.util.List;
public class Queues {
public static ListTask queue = new LinkedListTask();
/**
* 假如 参数o 为任务
* @param o
*/
public static void add (Task t){
synchronized (Queues.queue) {
Queues.queue.add(t); //添加任务
Queues.queue.notifyAll();//激活该队列对应的执行线程，全部Run起来
}
}
static class Task{
public void test(){
System.out.println("我被执行了");
}
}
}
package org;
import java.util.List;
public class Exec implements Runnable{
@Override
public void run() {
while(true){
synchronized (Queues.queue) {
while(Queues.queue.isEmpty()){ //
try {
Queues.queue.wait(); //队列为空时，使线程处于等待状态
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("wait...");
}
Queues.Task t= Queues.queue.remove(0); //得到第一个
t.test(); //执行该任务
System.out.println("end");
}
}
}
public static void main(String[] args) {
Exec e = new Exec();
for (int i = 0; i 2; i++) {
new Thread(e).start(); //开始执行时，队列为空，处于等待状态
}
//上面开启两个线程执行队列中的任务，那就是先到先得了
//添加一个任务测试
Queues.Task t =new Queues.Task();
Queues.add(t); //执行该方法，激活所有对应队列，那两个线程就会开始执行啦
}
}
上面的就是很简单的例子了
