多线程，Thread，线程安全问题，线程同步，线程通信，线程池

1，Thread的常用方法

Thread提供的常用方法	说明
public void run()	线程的任务方法
public void start(）	启动线程
public String getName()	获取当前线程的名称，线程名称默认是Thread-索引
public void setName(String name)	为线程设置名称
public static Thread currentThread(	获取当前执行的线程对象
public static void sleep(long time)	让当前执行的线程休眠多少毫秒后，再继续执行
public final void join(). . .	让调用当前这个方法的线程先执行完

Thread提供的常见构造器	说明
public Thread(String name)	可以为当前线程指定名称
public Thread( Runnable target)	封装Runnable对象成为线程对象
public Thread( Runnable target,String name)	封装Runnable对象成为线程对象，并指定线程名称

其他方法：Thread类还提供了诸如: yield、interrupt、守护线程、线程优先级等线程的控制方法，在开发中很少使用，这些方法会后续需要用到的时候再讲解

2，线程安全问题

什么是线程安全问题？

多个线程，同时操作同一个共享资源的时候，可能会出现业务安全问题

线程安全问题出现的原因?

1，存在多个线程在同时执行

2，同时访问一个共享资源

3，存在修改该共享资源

3，线程同步

是解决线程安全问题的方案

 线程同步的思想：让多个线程实现先后依次访问共享资源，这样就解决了安全问题

线程同步的常见方案

加锁:每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动解锁，然后其他线程才能再加锁进来

（1）同步代码块

作用：把访问共享资源的核心代码给上锁，以此保证线程安全

synchronized(同步锁){

        访问共享资源的核心代码

}

原理：每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行

同步锁的注意事项：

对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象），否则会出bug

锁对象随便选择一个唯一的对象好不好呢?

不好，会影响其他无关线程的执行

锁对象的使用规范

1，建议使用共享资源作为锁对象，对于实例方法建议使用this作为锁对象

        //this正好代表共享资源
        synchronized (this) {
            if (this.money>=money){
                System.out.println(name+"来取钱"+money+"成功了");
                this.money-=money;
                System.out.println(name+"来取钱后，余额剩余："+this.money);
            }else {
                System.out.println(name+"来取钱，余额不足~~~");
            }
        }

2，对于静态方法建议使用字节码(类名.class）对象作为锁对象

    public static void test(){
        synchronized (Account.class){

        }
    }

（2）同步方法

作用:把访问共享资源的核心方法给上锁，以此保证线程安全

修饰符 synchronized 返回值类型 方法名称(形参列表){

                操作共享资源的代码

}

原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行

public synchronized void drawMoney(double money)

同步方法底层原理

1，同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码

2，如果方法是实例方法：同步方法默认用this作为的锁对象

3，如果方法是静态方法：同步方法默认用类名.class作为的锁对象

是同步代码块好还是同步方法好一点?

范围上：同步代码块锁的范围更小，同步方法锁的范围更大

可读性：同步方法更好

（3）Lock锁

Lock锁是JDK5开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大

Lock是接口，不能直接实例化，可以采用它的实现类ReentrantLock来构建Lock锁对象

    //创建了锁对象
    private final Lock lk=new ReentrantLock();



    public void drawMoney(double money){
        String name=Thread.currentThread().getName();
        try {
            lk.lock();//加锁
            //this正好代表共享资源
            if (this.money>=money){
                System.out.println(name+"来取钱"+money+"成功了");
                this.money-=money;
                System.out.println(name+"来取钱后，余额剩余："+this.money);
            }else {
                System.out.println(name+"来取钱，余额不足~~~");
        }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lk.unlock();//解锁
        }
    }

构造器	说明
public ReentrantLock()	获得Lock锁的实现类对象

Lock常用方法

方法名称	说明
void lock()	获得锁
void unlock()	释放锁

4，线程通信

线程通信：当多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，以相互协调，并避免无效的资源争夺

线程通信的常见模型（生产者与消费者模型)

生产者线程负责生产数据

消费者线程负责消费生产者生产的数据

注意：生产者生产完数据应该等待自己，通知消费者消费;消费者消费完数据也应该等待自己，再通知生产者生产

Object类的等待和唤醒方法:

方法名称	说明
void wait()	让当前线程等待并释放所占锁，直到另一个线程调用notify()方法或notifyAll()方法
void notify()	唤醒正在等待的单个线程
void notifyAll()	唤醒正在等待的所有线程

注意：

上述方法应该使用当前同步锁对象进行调用

//唤醒别人，等待自己
this.notifyAll();
this.wait();

5，线程池

线程池：线程池就是一个可以复用线程的技术

不使用线程池的问题：

用户每发起一个请求，后台就需要创建一个新线程来处理，下次新任务来了肯定又要创建新线程处理的，而创建新线程的开销是很大的，并且请求过多时，肯定会产生大量的线程出来，这样会严重影响系统的性能

线程池的代表：

JDK 5.0起提供了代表线程池的接口:ExecutorService

（1）线程池的创建

如何得到线程池对象：

方式一：使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象

方式二︰使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象

1）ThreadPoolExecutor构造器

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,long keepAliveTime，TimeUnit unit,BlockingQueue<Runnable> workQueue，ThreadFactory threadFactory,RejectedExecutionHandler handler)

参数一：corePoolSize：指定线程池的核心线程的数量

参数二：maximumPoolSize：指定线程池的最大线程数量

参数三：keepAliveTime：指定临时线程的存活时间

参数四：unit：指定临时线程存活的时间单位(秒、分、时、天)

参数五：workQueue：指定线程池的任务队列

参数六：threadFactory：指定线程池的线程工厂

参数七：handler：指定线程池的任务拒绝策略（线程都在忙，任务队列也满了的时候，新任务来了该怎么处理）

ExecutorService pool=new ThreadPoolExecutor(3,5,8,
                TimeUnit.SECONDS,new ArrayBlockingQueue<>            
                (4),Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

2）线程池的注意事项

【1】临时线程的创建时间

新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程

【2】拒绝新任务的时间

核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始拒绝任务

（2）处理Runnable任务

ExecutorService的常用方法

方法名称	说明
void execute( Runnable command)	执行Runnable 任务
Future<T> submit(Callable<T> task)	执行Callable任务，返回未来任务对象，用于获取线程返回的结果
void shutdown()	等全部任务执行完毕后，再关闭线程池
List<Runnable> shutdownNow()	立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务

        Runnable target =new MyRunnable();
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);



public class MyRunnable4 implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"666");
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

新任务拒绝策略

策略	详解
ThreadPoolExecutor.AbortPolicy	丢弃任务并抛出RejectedExecutionException异常（是默认的策略）
ThreadPoolExecutor.DiscardPolicy	丢弃任务，但是不抛出异常，这是不推荐的做法
ThreadPoolExecutor.DiscardOldestPolicy	抛弃队列中等待最久的任务，然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy	由主线程负责调用任务的run(方法从而绕过线程池直接执行

（3）处理Callable任务

Executorservice的常用方法

方法名称	说明
void execute(Runnable command)	执行任务/命令，没有返回值,一般用来执行 Runnable任务
Future<T> submit(Callable<T> task)	执行任务，返回未来任务对象获取线程结果，一般拿来执行callable任务
void shutdown()	等任务执行完毕后关闭线程池
List<Runnable> shutdownNow()	立刻关闭，停止正在执行的任务，并返回队列中未执行的任务

        Future<String>f1 = pool.submit(new MyCallable(100));
        Future<String>f2 = pool.submit(new MyCallable(200));
        Future<String>f3 = pool.submit(new MyCallable(300));
        Future<String>f4 = pool.submit(new MyCallable(400));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());

（4）Executors工具类

Executors：是一个线程池的工具类，提供了很多静态方法用于返回不同特点的线程池对象

方法名称	说明
public static ExecutorService newFixedThreadPool(int nThreads)	创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代它
public static ExecutorService newSingleThreadExecutor()	创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程
public static ExecutorService newCachedThreadPool()	线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了60s则会被回收掉
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)	创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务

注意∶这些方法的底层，都是通过线程池的实现类ThreadPoolExecutor创建的线程池对象

 ExecutorService pool=Executors.newFixedThreadPool(3);

核心线程数量到底配置:

计算密集型的任务:核心线程数量=CPU核数+1

I0密集型的任务:核心线程数量= CPU核数*2

Executors使用可能存在的陷阱

大型并发系统环境中使用Executors如果不注意可能会出现系统风险

6，并发，并行

进程：

正在运行的程序（软件）就是一个独立的进程

线程是属于进程的，一个进程中可以同时运行很多个线程

进程中的多个线程其实是并发和并行执行的

（1）并发

进程中的线程是由CPU负责调度执行的，但CPU能同时处理线程的数量有限，为了保证全部线程都能往前执行,CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发

（2）并行

在同一个时刻上，同时有多个线程在被CPU调度执行

7，线程的生命周期

也就是线程从生到死的过程中，经历的各种状态及状态转换

理解线程这些状态有利于提升并发编程的理解能力

Java线程的状态

Java总共定义了6种状态

6种状态都定义在Thread类的内部枚举类中

public class Thread{
    ...
   public enum State{
        NEW,//新建
        RUNNABLE,//可运行
        BLOCKED,//阻塞
        WAITING,//无限等待
        TIME_WAITING,//计时等待
        TERMINATED;//被终止
    }
    ...
}

 线程6种状态总结

线程状态	说明
NEW(新建)	线程刚被创建，但是并未启动
Runnable(可运行)	线程已经调用了start()，等待CPU调度
Blocked(锁阻塞)	线程在执行的时候未竞争到锁对象,则该线程进入Blocked状态
Waiting(无限等待)	一个线程进入Waiting状态，另一个线程调用notify或者notifyAll方法才能够唤醒
Timed Waiting(计时等待)	同waiting状态，有几个方法(sleep,wait)有超时参数，调用他们将进入Timed waiting状态
Teminated(被终止)	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡

 8，乐观锁

private AtomicInteger count = new AtomicInteger();



count.incrementAndGet()  ==    ++count