一般情况下,创建一个线程,常采用三种方式:
1. 继承Thread类
2. 实现Runnable接口
3. 实现Callable接口
现在可以通过ThreadFactory新建线程,ThreadFacotry是线程的工厂类,采用设计模式中的工厂模式,这样我们就可以给该工厂中的所有线程进行统一的管理。
ThreadFactory接口:
public interface ThreadFactory {
/**
* Constructs a new {@code Thread}. Implementations may also initialize
* priority, name, daemon status, {@code ThreadGroup}, etc.
*
* @param r a runnable to be executed by new thread instance
* @return constructed thread, or {@code null} if the request to
* create a thread is rejected
*/
Thread newThread(Runnable r);
}
JDK实现了一个DefaultThreadFactory
static class DefaultThreadFactory implements ThreadFactory {
private static final AtomicInteger poolNumber = new AtomicInteger(1);
private final ThreadGroup group;
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
DefaultThreadFactory() {
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() :
Thread.currentThread().getThreadGroup();
namePrefix = "pool-" +
poolNumber.getAndIncrement() +
"-thread-";
}
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r,
namePrefix + threadNumber.getAndIncrement(),
0);
if (t.isDaemon())
t.setDaemon(false);
if (t.getPriority() != Thread.NORM_PRIORITY)
t.setPriority(Thread.NORM_PRIORITY);
return t;
}
}
下面实现一个基于线程工厂的多线程产者和消费者模式:
消息队列
public class Queue {
private LinkedBlockingQueue<String> queue ;
public LinkedBlockingQueue<String> getQueue() {
return queue;
}
public void setQueue(LinkedBlockingQueue<String> queue) {
this.queue = queue;
}
}
public class WorkThreadFactory implements ThreadFactory{
private static int count;
@Override
public Thread newThread(Runnable r) {
return new Thread(r, "线程"+ count++);
}
}
生产者
public class Producer {
private volatile int count = 0;
public void start(final Queue queue) {
WorkThreadFactory factory = new WorkThreadFactory();
Executor executor = Executors.newFixedThreadPool(5, factory);
for(int i=0; i<5; i++){
executor.execute(new Runnable() {
@Override
public void run() {
while(true){
produce(queue);
try {
Thread.sleep(1*100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
}
}
private String produce(Queue queue){
try {
String msg = "消息"+ ++count;
queue.getQueue().put(msg);
return msg;
} catch (InterruptedException e) {
e.printStackTrace();
}
return "";
}
}
消费者
public class Customer {
public void start(final Queue queue) {
WorkThreadFactory factory = new WorkThreadFactory();
ExecutorService executor = Executors.newFixedThreadPool(5, factory);
for(int i = 0;i<5; i++){
executor.execute(new Runnable() {
@Override
public void run() {
while(true){
customer(queue);
/*try {
Thread.sleep(1*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}*/
}
}
});
}
}
private void customer(Queue queue){
String msg = queue.getQueue().poll();
if(StringUtils.isNotBlank(msg)){
System.out.println(Thread.currentThread().getName()+"消费+"+msg);
}
}
}
主线程
public class MainThread {
public static void main(String[] args) {
Queue queue = new Queue();
queue.setQueue(new LinkedBlockingQueue<String>());
Customer customer = new Customer();
Producer producer = new Producer();
producer.start(queue);
customer.start(queue);
}
}