线程池

 

 

 

 

 

 

 public static void main(String[] args) {
        //创建线程池，并指定线程池中线程的数量
        ExecutorService pool = Executors.newFixedThreadPool(2);

        Runnable r = new Runnable() {

            @Override
            public void run() {
                String name = Thread.currentThread().getName();
                System.out.println(name+"正在执行");
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(name+"执行完毕，线程归还给线程池");
            }
        };
        pool.submit(r);
        pool.submit(r);
        pool.submit(r);

        pool.shutdown();


    }

　　

public static void main(String[] args) {
        String lockA = "A";
        String lockB = "B";
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    synchronized (lockA){
                        System.out.println("线程一，获取到锁A，在等待锁B。。。");

                        synchronized (lockB){
                        System.out.println("线程一，获取到A和B。。。");
                        }
                    }
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    synchronized (lockB){
                        System.out.println("线程二，获取到锁B，在等待锁A。。。");

                        synchronized (lockA){
                            System.out.println("线程二，获取到A和B。。。");
                        }
                    }
                }
            }
        }).start();
    }

　　

 

 

 public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (DengdaiHuanxing.class){
                    System.out.println("我要睡觉了！~");
                    System.out.println("Zzz");
                    try {
                        DengdaiHuanxing.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("醒了");
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (DengdaiHuanxing.class){
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("快起来，睡什么睡");
                    DengdaiHuanxing.class.notify();
                }
            }
        }).start();
    }

　　

package com.cntaiping.tpi.claimplat.serviceapi.Test10.xianchengchi;

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

public class Demo01 {

	/*1、FixedThreadPool
	 * 固定容量线程池。其特点是最大线程数就是核心线程数，意味着线程池只能创建核心线程，keepAliveTime为0，即线程执行完任务立即回收。
	 * 任务队列未指定容量，代表使用默认值Integer.MAX_VALUE。适用于需要控制并发线程的场景。
	 */
	public static void main(String[] args) {
		// 1. 创建线程池对象，设置核心线程和最大线程数为5
		ExecutorService fixedThreadPool = Executors.newFixedThreadPool(1);
		// 2. 创建Runnable（任务）
		Runnable task =new Runnable(){
		  public void run() {
		     System.out.println(Thread.currentThread().getName() + "--->运行");
		     try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		     System.out.println(Thread.currentThread().getName() + "--->运行完毕");
		  }
		};
		// 3. 向线程池提交任务
		fixedThreadPool.execute(task);
		fixedThreadPool.execute(task);
		fixedThreadPool.execute(task);
		fixedThreadPool.execute(task);
		fixedThreadPool.execute(task);
		fixedThreadPool.execute(task);
		fixedThreadPool.execute(task);
		fixedThreadPool.execute(task);
		
		fixedThreadPool.shutdown();
}
}

　　

package com.cntaiping.tpi.claimplat.serviceapi.Test10.xianchengchi;

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

public class Demo02 {

/*
 * 2、 SingleThreadExecutor
               单线程线程池。特点是线程池中只有一个线程（核心线程），线程执行完任务立即回收，使用有界阻塞队列（容量未指定，使用默认值Integer.MAX_VALUE）
 */
	public static void main(String[] args) {
		// 1. 创建线程池对象，设置核心线程和最大线程数为5
		ExecutorService fixedThreadPool = Executors.newSingleThreadExecutor();
		// 2. 创建Runnable（任务）
		Runnable task =new Runnable(){
		  public void run() {
		     System.out.println(Thread.currentThread().getName() + "--->运行中");
		     try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		     System.out.println(Thread.currentThread().getName() + "--->运行完毕，返回线程池");
		  }
		};
		// 3. 向线程池提交任务
		fixedThreadPool.execute(task);
		fixedThreadPool.execute(task);
		fixedThreadPool.execute(task);
		fixedThreadPool.execute(task);
		fixedThreadPool.execute(task);
		fixedThreadPool.execute(task);
		
		fixedThreadPool.shutdown();
}
}

　　

package com.cntaiping.tpi.claimplat.serviceapi.Test10.xianchengchi;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Demo03 {
	/*
	 * 
	 * 3、 ScheduledThreadPool
	 * 定时线程池。指定核心线程数量，普通线程数量无限，线程执行完任务立即回收，任务队列为延时阻塞队列。这是一个比较特别的线程池，适用于执行定时或周期性的任务。
	 */
	public static void main(String[] args) {
		// 1. 创建定时线程池
		ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(1);
		// 2. 创建Runnable（任务）
		Runnable task = new Runnable() {
			public void run() {
				System.out.println(Thread.currentThread().getName() + "--->运行中");
				System.out.println(Thread.currentThread().getName() + "--->运行完毕，返回线程池");
			}
		};
		// 3. 向线程池提交任务
		
		  newScheduledThreadPool.schedule(task, 3, TimeUnit.SECONDS);// 延迟3s后执行任务
		 
		newScheduledThreadPool.scheduleAtFixedRate(task, 50, 3000, TimeUnit.MICROSECONDS);// 延迟50ms后、每隔3000ms执行任务

		newScheduledThreadPool.shutdown();

	}
}

　　

package com.cntaiping.tpi.claimplat.serviceapi.Test10.xianchengchi;

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

public class Demo04 {

	/*
	 * 4、CachedThreadPool 缓存线程池。没有核心线程，普通线程数量为Integer.MAX_VALUE（可以理解为无限），线程闲置60s后回收，
	 * 任务队列使用SynchronousQueue这种无容量的同步队列。适用于任务量大但耗时低的场景
	 */
	public static void main(String[] args) {
		// 1. 创建缓存线程池
		ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
		// 2. 创建Runnable（任务）
		Runnable task = new Runnable(){
		  public void run() {
		     System.out.println(Thread.currentThread().getName() + "--->运行中");
		     System.out.println(Thread.currentThread().getName() + "--->运行完毕");
		  }
		};
		// 3. 向线程池提交任务
		cachedThreadPool.execute(task);
		cachedThreadPool.execute(task);
		cachedThreadPool.execute(task);
		cachedThreadPool.execute(task);
		
		cachedThreadPool.shutdown();
	}
}