线程和线程池的理解与java简单例子

1.线程

（1）理解,线程是系统分配处理器时间资源的基本单元也是系统调用的基本单位，简单理解就是一个或多个线程组成了一个进程,进程就像爸爸，线程就像儿子，有时候爸爸一个人干不了活就生了几个儿子干活，会比较快，例如你打开视频软件在线看视频，那有一个线程负责下载，一个线程负责播放...,视频软件就相当爸爸，线程就像儿子们，好处就是可以并发，效率高；

（2）线程一般有两种方法，很简单  下面例子懒得写以前有参照过别人的 http://www.myexception.cn/program/1056162.html

2-1.继承Thread线程类

class ThreadUseExtends extends Thread
//通过继承Thread类,并实现它的抽象方法run()
//适当时候创建这一Thread子类的实例来实现多线程机制
//一个线程启动后（也即进入就绪状态）一旦获得CPU将自动调用它的run()方法
{

      ThreadUseExtends(){}//构造函数
      public void run()
      {
              System.out.println("我是Thread子类的线程实例!");
              System.out.println("我将挂起10秒!");
              System.out.println("回到主线程,请稍等,刚才主线程挂起可能还没醒过来！");
              try
              {
                      sleep(10000);//挂起10秒
              }
              catch (InterruptedException e)
              {
                      return;
              }
              //如果该run()方法顺序执行完了,线程将自动结束,而不会被主线程杀掉
              //但如果休眠时间过长,则线程还存活,可能被stop()杀掉
      }
}

　　2-2.实现 Runnable接口 代码简单

class ThreadUseRunnable implements Runnable
//通过实现Runnable接口中的run()方法,再以这个实现了run()方法的类
//为参数创建Thread的线程实例
{
      //Thread thread2=new Thread(this);
      //以这个实现了Runnable接口中run()方法的类为参数创建Thread类的线程实例
      ThreadUseRunnable(){}//构造函数
      public void run()
      {
              System.out.println("我是Thread类的线程实例并以实现了Runnable接口的类为参数!");
              System.out.println("我将挂起1秒!");
              System.out.println("回到主线程,请稍等,刚才主线程挂起可能还没醒过来！");
              try
              {
                      Thread.sleep(1000);//挂起1秒
              }
              catch (InterruptedException e)
              {
                      return;
              }
              //如果该run()方法顺序执行完了,线程将自动结束,而不会被主线程杀掉
              //但如果休眠时间过长,则线程还存活,可能被stop()杀掉
      }

}

　2-3.接下来测试以上两个类　

public class ThreadTest {
	/**
	 *学习多线程例子
	 * @param args
	 * @author JJ
	 */
	public static void main(String[] args) {
		 System.out.println("我是主线程!");
         //下面创建线程实例thread1
         ThreadUseExtends thread1=new ThreadUseExtends();
         //创建thread2时以实现了Runnable接口的THhreadUseRunnable类实例为参数
         Thread thread2=new Thread(new ThreadUseRunnable(),"SecondThread");
         thread1.start();//启动线程thread1使之处于就绪状态
         //thread1.setPriority(6);//设置thread1的优先级为6
         //优先级将决定cpu空出时，处于就绪状态的线程谁先占领cpu开始运行
         //优先级范围1到10,MIN_PRIORITY,MAX_PRIORITY,NORM_PAIORITY
         //新线程继承创建她的父线程优先级,父线程通常有普通优先级即5NORM_PRIORITY
         System.out.println("主线程将挂起7秒!");
         try
         {
                 Thread.sleep(3000);//主线程挂起7秒
         }
         catch (InterruptedException e)
         {
                 return;
         }
         System.out.println("又回到了主线程1!");
         if(thread1.isAlive())
         {
                 thread1.stop();//如果thread1还存在则杀掉他
                 System.out.println("thread1休眠过长,主线程杀掉了thread1!");
         }
         else
                 System.out.println("主线程没发现thread1,thread1已醒顺序执行结束了!");
         thread2.start();//启动thread2
         System.out.println("主线程又将挂起7秒!");
         try
         {
                 Thread.sleep(7000);//主线程挂起7秒
         }
         catch (InterruptedException e)
         {
                 return;
         }
         System.out.println("又回到了主线程2!");
         if(thread2.isAlive())
         {
                 thread2.stop();//如果thread2还存在则杀掉他
                 System.out.println("thread2休眠过长，主线程杀掉了thread2!");
         }
         else
                 System.out.println("主线程没发现thread2,thread2已醒顺序执行结束了!");
         System.out.println("程序结束按任意键继续!");
         try
         {
                 System.in.read();
         }
         catch (IOException e)
         {
                 System.out.println(e.toString());
         }

 }//main
	}

　　2-4.运行查看效果

2.线程池

（1）理解，线程池就是用来管理线程的，线程要创建摧毁很耗时和内存资源，就像一次性筷子生产到扔掉，我们线程池就像家用筷子，可以用很多次，线程池就是这么一个作用

（2）例子，我觉得冯小卫写了很好我参考了一下他的 http://blog.csdn.net/coding_or_coded/article/details/6856014，线程池有好几种，各有利弊

2-1.固定大小的线程池，newFixedThreadPool：

1. package app.executors;
2. import java.util.concurrent.Executors;
3. import java.util.concurrent.ExecutorService;
4. /**
5. * Java线程：线程池
6. *
7. * @author 冯小卫
8. */
9. public class Test {
10. public static void main(String[] args) {
11. // 创建一个可重用固定线程数的线程池
12. ExecutorService pool = Executors.newFixedThreadPool(5);
13. // 创建线程
14. Thread t1 = new MyThread();
15. Thread t2 = new MyThread();
16. Thread t3 = new MyThread();
17. Thread t4 = new MyThread();
18. Thread t5 = new MyThread();
19. // 将线程放入池中进行执行
20. pool.execute(t1);
21. pool.execute(t2);
22. pool.execute(t3);
23. pool.execute(t4);
24. pool.execute(t5);
25. // 关闭线程池
26. pool.shutdown();
27. }
28. }
29. class MyThread extends Thread {
30. @Override
31. public void run() {
32. System.out.println(Thread.currentThread().getName() + "正在执行。。。");
33. }
34. }

　　运行结果和其他解释具体可以参照一下上面链接