线程的基本概念及线程池函数

一、线程的基本概念
1、线程是CPU调度的最小单位
2、一个进程中至少包含一条线程：主线程
3、主线程是系统创建的
4、java中主线程的入口 public static void main(String[] args){}
5、线程的状态

二、关于线程的阻塞
Thread.sleep(long milliseconds);
t.wait(); 一直等，直到（锁在同一把锁）有人通知
t.wait(long milliseconds)；等milliseconds,（锁在同一把锁）有人通知立即执行，无人通知等超过milliseconds后自动恢复执行
t.notify(); 通知另一个人
t.notifyAll(); 通知其他所有的人

三、java中创建线程的方式
1、创建java.lang.Thread的子类:重写Thread的run方法

class MyThread1 extends Thread{
		@Override
        public void run(){
			setName("sub1");
			try{
				for(int i=0; i<100;i++){
					synchronized (lock){
						if(count%2!=0){
							lock.wait();
						}
						System.out.println(this.getName() +" : "+i);
						count++;
						lock.notify();
						Thread.sleep(1000);
					}
				}
			}catch (InterruptedException e){
				e.printStackTrace();
			}
		}
	}
	
	MyThread1 mt = new MyThread1();
	mt.start();

2、匿名内部类创建Thread的对象:重写Thread的run方法

Thread t = new Thread(){
        @Override
        public void run(){
            for(int i=0; i<100;i++){
                System.out.println("Sub:"+i);
                try{
                    Thread.sleep(1000);
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
        }
    };
	t.start();
	

3、创建Runnable接口对象，作为java.lang.Thread的构造参数传入

	Runnable run1 =new Runnable () {
		@override
		public void run () {
			try {
				for (int i = 0; i <100 ; i++){
					synchronized (lock){
						if (count%2!=0 ){
						lock.wait ();
						}
						system.out.println (Thread.currentThread () .getName ()+": "+ i);
						count++;
						lock. notify ();
						Thread.sleep ( 1000) ;
					}
				}
			}catch (InterruptedException e) {
				e.printstackTrace () ;
			}
		}
	};
	
	Thread t =new Thread (run1);
	t .start() ;

以上三种创建线程的方式，都是判断100以内的数的奇偶数，来决定是否线程进入阻塞状态。这样还举例了线程阻塞的情况。

四、ExecutorService 普通线程池
1、固定线程池：池中养固定数量的线程，并发需求超出最大线程数，则等待
ExecutorService pool = Executors.newFixedThreadPool(2);
2、实现固定数量的线程的步骤

   for (int i = 0; i < 3; i++) {
              final int _i = i;   //在线程里面必须实例或常量 _i
           pool.submit(new Runnable() {
               @Override
               public void run() {
                    for (int j = 0; j <100 ; j++) {
                       System.out.println("Thread"+_i+"\t"+j);
                        try {
                           Thread.sleep(100);
                      } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
               }
            });
        }
        pool.shutdown();

五、线程池函数
1、固定线程池
ExecutorService pool = Executors.newFixedThreadPool(int size);
2、缓存线程池：初始化不创建任何线程，根据。当线程闲置到一定的阀值是会被大量回收
ExecutorService pool = Executors.newCachedThreadPool();
3、单线线程池：只维护一条线程
ExecutorService one = Executors.newSingleThreadExecutor();

向线程池的submit方法，传入Runnable\Callablle来完成指定任务
①xxxPool.submit(Runnable task); //无返回值
②Future future = xxxPool.submit(Callable call); //有返回值

1、计划线程池：根据需要在指定时间执行、或以固定的周期、或固定延时执行的线程池
ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(int size);
2、延迟多久执行一次（一次性执行）
scheduledPool.schedule(Runnable run,int delay,TimeUnit unit);
scheduledFutrue future = scheduledPool.schedule(Callable run,int delay,TimeUnit unit);
3、每隔多久执行一次
scheduledPool.scheduleAtFixedDelay(Runnable run,int initialDelay,int period,TimeUnit unit)
4、执行完延迟多久执行下一次
scheduledPool.scheduleWithFixedDelay(Runnable run,int initialDelay,int delay,TimeUnit unit)

最后，释放线程池
xxxPool.shutdown();