多线程编程小案例（二）

public class Student {
	private Integer id;
	private String name;
	private Integer age;
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
}

需求：模拟查询100条数据
1、通过100个线程实现

2、通过线程池实现

1、通过创建100个线程实现：

/**
 * 模拟使用100个线程查询100个用户的信息 ，并将信息存储到队列中去
 */
public class TestThreads {
	public static void main(String[] args) {
		LinkedBlockingQueue<Student> queue = new LinkedBlockingQueue<>();
		Query query = new Query(queue);
		
		int i = 0;
		Thread thread = null;
		//产生100个线程
		for(;i < 100;i++){
			if(i == 0){
				System.out.println(System.currentTimeMillis());
			}
			thread = new Thread(new QueryStudent(query));
			thread.start();
			thread.setName("thread-"+i);
		}
	}
}

/**
 * 查询操作
 */
class Query{
	LinkedBlockingQueue<Student> queue;
	private int i = 0 ;
	
	public Query(LinkedBlockingQueue<Student> queue){
		this.queue = queue;
	}
	
	//查询方法
	public synchronized void queryStudent(){
		try {
			i++;
			if(i == 100){
				notifyAll();
				System.out.println(System.currentTimeMillis());
			}
			
			Student stu = new Student();
			stu.setId(i);
			stu.setName("zrl"+i);
			stu.setAge(5+i);
			
			queue.put(stu);
			System.out.println(Thread.currentThread().getName()+":查询到："+stu.toString());
			Thread.sleep(100);
			wait();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

/**
 * 线程 
 */
class QueryStudent implements Runnable{
	private Query query;
	
	public QueryStudent(Query query){
		this.query = query;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		query.queryStudent();
	}
}

2、通过线程池实现

（1）未封装

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

public class TestPool2 {
	public static void main(String[] args) {
		LinkedBlockingQueue<Student> queue = new LinkedBlockingQueue<>();
		
		//定义容量为10的线程池
		ExecutorService executor = Executors.newFixedThreadPool(10);
		
		for(int i = 0 ;i < 100;i++){
			executor.execute(new QueryStudentPool2(i,queue));
			 
		}
		
        try {
			Thread.sleep(100);  
			executor.shutdown();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}  
	}
}


class QueryStudentPool2 implements Runnable{
	LinkedBlockingQueue<Student> queue;
	private int num;
	
	public QueryStudentPool2(int num,LinkedBlockingQueue<Student> queue){
		this.num = num;
		this.queue = queue;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			Thread.sleep(100);
			num++;
			
			Student stu = new Student();
			stu.setId(num);
			stu.setName("zrl"+num);
			stu.setAge(5+num);
			
			queue.put(stu);
			System.out.println(Thread.currentThread().getName()+":查询到："+stu.toString());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

（2）封装

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * 采用线程池
 */
public class TestPool {
	public static void main(String[] args) {
		LinkedBlockingQueue<Student> queue = new LinkedBlockingQueue<>();
		QueryPool query = new QueryPool(queue);
		
		ExecutorService executor = Executors.newFixedThreadPool(10);
		
		for(int i = 0 ;i < 100;i++){
			executor.execute(new QueryStudentPool(query));
		}
        try {
			Thread.sleep(100);  
			executor.shutdown();
			while(true){
				if(executor.isTerminated()){
					System.out.println("查询结束");
					break;
				}
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}  
	}
}

class QueryPool{
	LinkedBlockingQueue<Student> queue;
	private int i = 0 ;
	
	public QueryPool(LinkedBlockingQueue<Student> queue){
		this.queue = queue;
	}
	
	public synchronized void queryStudent(){
		try {
			i++;
			
			Student stu = new Student();
			stu.setId(i);
			stu.setName("zrl"+i);
			stu.setAge(5+i);
			
			queue.put(stu);
			System.out.println(Thread.currentThread().getName()+":查询到："+stu.toString());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

class QueryStudentPool implements Runnable{
	private QueryPool query;
	
	public QueryStudentPool(QueryPool query){
		this.query = query;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			Thread.sleep(100);
			query.queryStudent();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

采用线程池之后，效率明显比创建100个线程高许多