线程知识简单总结

1.volatile关键字

• 多线程操作共享数据时
• 保证数据可见 不具备”互斥性“
• 不能保证变量的原子性

2.CopyOnWriteArrayList

• 添加操作多时，效率低，每次添加都会进行复制，开销大，并发迭代操作多时可以选择

3.CountDownLatch

• 闭锁 只有其他线程全部完成时 最后线程才算完成，计算多个线程操作时间总和

4.Callable

• 实现Callable 接口 创建线程 具有返回值， 需要FutureTask 用于接收运算结果

5.解决多线程安全的方式

• 同步代码块
• 同步方法
• 同步锁 Lock （1.5以后）

Demo1循环打印ABC:

public class Test{
	public static void main (String[] args){
		AlternateDemo demo = new AlternateDemo();
		new Thead(new Runnable(){
			@Override
			public void run(){
				for(int i=1;i<=20;i++){
					demo.loopA(i);
				}
			}
		},"A").start();
		new Thead(new Runnable(){
			@Override
			public void run(){
				for(int i=1;i<=20;i++){
					demo.loopB(i);
				}
			}
		},"B").start();
		new Thead(new Runnable(){
			@Override
			public void run(){
				for(int i=1;i<=20;i++){
					demo.loopC(i);
				}
			}
		},"C").start();
	}
}

class AlternateDemo{
	private int number = 1;
	private Lock lock = new ReentrantLock();
	private Condition condition1 = lock.newCondition();
	private Condition condition2 = lock.newCondition();
	private Condition condition3 = lock.newCondition();
	
	//循环几轮  totalLoop
	public void loopA(int totalLoop){
		lock.lock();
		try{
			if(number != 1){
				condition1.await();
			}
			for(int i = 1; i <=5; i++){
				System.out.println(Thread.currentThread().getName() + “\t” +i+ “\t” +totalLoop);
			}
			number = 2;
			condition2.signal();
		} catch (Exception e){
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}

	public void loopB(int totalLoop){
		lock.lock();
		try{
			if(number != 2){
				condition2.await();
			}
			for(int i = 1; i <=5; i++){
				System.out.println(Thread.currentThread().getName() + “\t” +i+ “\t” +totalLoop);
			}
			number = 3;
			condition3.signal();
		} catch (Exception e){
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	public void loopC(int totalLoop){
		lock.lock();
		try{
			if(number != 3){
				condition3.await();
			}
			for(int i = 1; i <=5; i++){
				System.out.println(Thread.currentThread().getName() + “\t” +i+ “\t” +totalLoop);
			}
			number = 1;
			condition1.signal();
		} catch (Exception e){
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}


}

非静态方法的锁默认为 this，静态方法的锁为 对应的Class 实例

某个时刻内，只能有一个线程持有锁，无论几个方法

线程池：提供了一个线程队列，保存着所有等待状态的线程。

线程池的体系结构

java.util.concurrent.Executor ：负责线程的使用与调度的跟接口
|–ExecutorService 子接口： 线程池的主要接口
|–ThreadPoolExecutor 线程池的实现类
|–ScheduledExecutorService 子接口：负责线程的调度
|–ScheduledThreadPoolExecutor: 继承ThreadPoolExecutor，实现ScheduledExecutorService

工具类 Executors

ExecutorService newFixedThreadPool() : 创建固定大小的线程池
ExecutorService newCachedThreadPool() : 缓存线程池，数量不固定，可以根据需求自动的更改数量
ExecutorService newSingleThreadExecutor() : 创建单个线程池，只有一个线程
ScheduledExecutorService newScheduledThreadPool() : 创建固定大小的线程，可以延迟或者定时的执行