java多线程

工作上用到java多线程的机会很少，在这，我想就java多线程进行深入探讨，线程和进程一样，拥有5个状态，创建，就绪，运行，阻塞，结束。我们平时写代码，有两种方式实现java多线程，一种是继承Thread类，一种是实现Runable接口。

package test;

public class thread1 extends Thread{
   private String name;
   
   public thread1(String name){
	   this.name=name;
   }
   
   public void run(){
	   for(int i=0;i<=4;i++){
		   System.out.println(name+"正在运行！！");
		   try{
			   sleep(100);
		   }catch(Exception e){
			   e.printStackTrace();
		   }
	   }
   }
   
   public static void main(String[] args) {
		// TODO Auto-generated method stub
       Thread th1=new thread1("线程1号");
       Thread th2=new thread1("线程2号");
       th1.start();
       th2.start();
	}
}

在该代码中我只调用了sleep方法，其实还有wait方法，两种的差别在于sleep不让出资源，wait让出资源。

实现Runnable

package test;

public class runable implements Runnable{
    private String name;
    
    public runable(String name){
       this.name=name;
    }
    
	@Override
	public synchronized void run() {
		// TODO Auto-generated method stub
		  for(int i=0;i<=4;i++){
			   System.out.println(name+"正在运行！！");
			   try{
				   wait(300);
			   }catch(Exception e){
				   e.printStackTrace();
			   }
		   }
	}
	
	  public static void main(String[] args) {
			// TODO Auto-generated method stub
	       new Thread(new runable("线程1")).start();
	       new Thread(new runable("线程2")).start();
		}

}

调用Runnable接口比继承Thread类更加适合于共享资源。

看到java多线程受这么多人关注，我决定再补充些内容。

其实，我们开发过的软件，只要有多人使用，就会涉及到多线程，例如，网站前台，多个用户请求相同功能时，这时，每个用户的请求会产生一条消息，每条消息伴随着是一个线程，后台接收到这些消息之后，根据请求的先后进行对方法资源的争夺，这是多线程竞争资源的情形，平时，这些多线程请求资源都是有序的，一个完成再到下一个。如果存在特殊情况，这些线程请求资源已经达到了高并发，我们可以强制性的加上同步锁（synchronized），来进行强制同步。

我举例说明下，怎么用消息队列来管理多线程。

package test;

import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class test {

	/**
	 * @param args
	 */
	private static List<Queue> queueCache=new LinkedList<Queue>();//定义一个队列缓存池
	private static Integer offerMaxQueue=2000;//定义队列缓存池最大消息数
	private  String queueStr=null;
	public  void test() {
		// TODO Auto-generated method stub
        //定义检出线程
		new Thread(){
			public void run(){
				while(true){
					String ip=null;
					try{
						synchronized (queueCache) {
							Integer size=queueCache.size();
							if(size==0){
								//队列缓冲池没有消息，等待、、、
							}
							Queue queue=queueCache.remove(0);
							if(isLock(queueStr)){
								queueCache.add(queue);//重新加入队列
								continue;
							}else{
								//处理该消息
							}
						}
						
					}catch(Exception e){
						
					}finally{
						try{
							upLock(queueStr);
						//检出该消息队列的锁
						}catch(Exception e){
							
						}
					}
				}
			}
		}.start();
		//定义检入队列
		synchronized (queueCache) {
		   while(true){
			   Integer size=queueCache.size();
			   if(size>=offerMaxQueue){
				   try{
					   queueCache.wait();//不释放资源，进入等待
				   }catch(Exception e){
					   
				   }
			   }
			   if(size<offerMaxQueue&&size>0){
				   queueCache.notifyAll();//唤醒线程
			   }
			   break;
		   }
		}
	}
    
	/**
	 * 实现锁方法
	 * @param queueStr
	 * @return
	 */
	public Boolean isLock(String queueStr){ 
		return null;
	}
	
	/**
	 * 解锁方法
	 */
	public void upLock(String queueStr){
		
	}
}

下面我来说说很容易被我们遗忘的关于java多线程操作的方法。

关于使用 ExecutorService oExecService = Executors  .newFixedThreadPool(num);  来使用多线程点击打开链接

.wait(),.notify(),.notifyAll();都是关于使用多线程要用到的。点击打开链接