多线程：线程的常用方法和线程池

线程

线程：cpu调度的最小单位
一个进程中至少包含一条线程：主线程
主线程是系统创建的
java中主线程的入口为public static void main (String[] args){}

线程的状态

1.新生		new born
			↓
2.就绪		ready		 ←
			↓						↑
3.运行		running 	 →  	阻塞 bblock
			↓
4.死亡		dead

线程阻塞

Thread.sleep(int milliseconds);//进程睡眠多少毫秒
//多个进程交替运行
t.wait();//等同一把锁下
t.wait(long milliseconds);//等milliseconds后(锁在同一把锁)有人通知立即执行,无人通知等超过milliseconds后自动恢复执行
t.notify();//通知另一个人
t.notifyAll();//通知其他人

创建线程

1.创建java.lang.Thread的子类，重写Thread的run方法

class MyThread 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(count82!=0){
					lock.wait ();
				}
			system.out.println (Thread.currentThread () .getName () +" : "+i) ;
			count++;
			lock.notify () ;
			Thread.sleep (1000);
			}
		}
	}catch (工nterruptedException e){
		e.printstackTrace () ;
	}
};
Thread t =new Thread (run1) ;
t.start () ;
		

线程池

管理线程的工具

1. 固定线程池

//池中养固定数量的线程，有空余线程正常申请，无空余则等待；并发需求超出最大线程数，则等待;直到有线程被释放到线程池
ExecutorService fixedpool= Executors.newFixedThreadPool(int size);
      for (int i = 0; i < 3; i++) {//两个线程
          final int _i=i;
          pool.submit(new Runnable() {
              @Override
              public void run() {
                  for (int j = 0; j <20 ; j++) {
                      System.out.println("Thread"+_i+"\t"+j);
                      try {
                          Thread.sleep(100);
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                  }
              }
          });
      }

   pool.shutdown();

2.缓存线程池

//初始化不创建任何线程，根据需要创建线程；当线程闲置达到阈值会被回收
ExecutorService cachedpool=Executors.newCachedThreadPool();//小型任务

3.单线程池

//只维护一条线程的线程池
ExecutorService singlePool=Executors.newSingleThreadExecutor();

//1-3通过Runable/Callcble对象传入线程池中submit方法去执行指定的业务代码，
xxxPool.submit(Runnable task);
Future<> future=xxxPool.submit(Callcble<T> call)

4.计划线程池

//根据需要在指定时间或固定的周期或固定延时重复执行线程池
    ScheduledExecutorService
    ScheduledExecutorService scheduledPool=Executors.newScheduledThreadPool(3);
//让任务延时到指定时间执行（一次执行）
	scheduledPool.schedule(new Runnable(Runnable run,int delay,TimeUnit) ;
	scheduleFuture<T> future =scheduledPool.schedule(Callable<T> run,int delay,TimeUnit);
	  
//让任务在2单位后第一次执行，每隔1单位时间再执行一次；
	sheduledPool.scheduleAtFixedRate(new Runnable()},2,1, TimeUnit);
//让任务执行完多久执行下一次
 	scheduledPool.scheduleWithFixedDelay(new Runnable() ,1,2, TimeUnit);

//释放线程
	xxxPool.shutdown();```