多线程sleep与interrupt性能

0 0

多线程sleep与interrupt性能30

一个管理线程ManagerThread，多个业务线程BusinessThread
管理线程获得数据后，需要交给业务线程处理，平时业务线程都是sleep状态，由管理线程决定唤起哪几个业务线程。
两种方式可用：
1.BusinessThread一直都sleep，直至ManagerThread调用interrupt中断，执行完业务后继续sleep；
2.BusinessThread加个wakeup的标识属性，循环sleep(1000)，每个循环间隙去判断自身标识属性，来确定是否执行业务。
由于业务线程可能要求比较多，所以需要评估一下性能，
我觉得1用的资源比较少，但2比较灵活，但是不确定，1和2哪种更合理。

问题补充：以前用过线程池，但是创建与释放过于频繁，一段时间后容易出现out of memory之类的异常。当然跟jvm参数配置不当也有关，但是线程稳定的话，异常几率大幅减少。

2013年7月09日 09:40

shy315
0
0 0 2

6个答案按时间排序按投票排序

0 0

线程池创建和释放线程不可能有内存问题，除非你的线程池最大线程数过大，并且过期销毁的时间太长。

2013年7月11日 12:58

Shen.Yiyang
40
0 1 6

添加评论

0 0

性能上肯定是第一种模型性能好,
但不推荐用 sleep interrupt ,java 的 wait 和 notify 就是可以,用来减少 cpu 轮询.

附上一个最最简单的实现:

public class MainTest {

	public static Object lock = new Object();

	public static void main(String[] args) throws InterruptedException {
		ThreadClass t1 = new ThreadClass();
		ThreadClass t2 = new ThreadClass();
		ThreadClass t3 = new ThreadClass();

		t1.start();
		t2.start();
		t3.start();
		
		synchronized (lock) {
			lock.notifyAll();
		}
	}

	public static class ThreadClass extends Thread {
		@Override
		public void run() {
			System.out.println(this.getId() + ",run");
			synchronized (lock) {
				try {
					lock.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				// TODO 获取任务对象,跳出synchronized 模块,否则继续wait
			}
		}
	}
}

不过猜测楼主的业务是:
要为每个业务线程都加一个锁对象,当这个业务线程应该开始去执行的时候,就去调用这个业务线程使用的锁对象的 notify ,就可以了.

2013年7月11日 10:14

id.alex
10
0 1 10

1条评论

0 0

package thread.iteye;

import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;

public class ThreadTest {

    public static void main(String[] args) {
        Queue<Object> tasks = new ArrayBlockingQueue<Object>(10);
        ManagerThread mt = new ManagerThread(tasks);
        BusinessThread bt = new BusinessThread(tasks);
        BusinessThread bt1 = new BusinessThread(tasks);
        mt.start();
        bt.start();
        bt1.start();
    }
}

class ManagerThread extends Thread{
    private Queue<Object> tasks;
    public ManagerThread(Queue<Object> tasks){
        this.tasks = tasks;
    }

    public void run(){
        while(true){
            addTask();
            if(!tasks.isEmpty()){
                synchronized(tasks){tasks.notify();}//唤醒消费者
            }
        }

    }

    public void addTask(){
        if(tasks.size()<10){
            tasks.add("aaa");
        }
    }
}

class BusinessThread extends Thread{
    private Queue<Object> tasks;
    public BusinessThread(Queue<Object> tasks){
        this.tasks = tasks;
    }
    public void run(){
        while(true){
            Object task = tasks.poll();
            //some code do task
            if(task!=null){
                execute(task);
                try {
                    synchronized(tasks){tasks.wait();}//等待下次任务
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }

    public void execute(Object task){
        try {
            Thread.sleep(10000);//执行任务需要一定时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+" execute aaa");
    }
}