Java线程通信概述及并发编程变量不可见性的原因和解决

1.线程通信

前提：保证线程通信的安全性；

线程通信的知识需要参考操作系统，此处代码后续有各种的模板将其封装好；

1.1线程通信Object提供的核心方法

public void waite(); //线程状态进入到等待，此方法必须要锁对象调用；

public void notify(); //唤醒某一个等待的线程

public void notifyAll(); //唤醒所有等待的线程

notify的本意就是通知

1.2简单的生产者消费者框架

while(True)	{
	***
	
	acc.save(money);
	
	notify(customer);


}

上述问题与操作系统保持一致，生产者消费者使用循环等待的方式进行操作；

1.3线程状态

线程状态有

1.新建

2.执行 4.就绪 5.阻塞

3.终止

由最简单的左边一列的三状态演变成为5状态；

2.线程池

概念

线程属于宝贵资源，频繁创建线程极大消耗性能，线程并发数量很多系统很容易死机

线程池就是实现线程复用的效果，执行完下一个任务后，不被销毁，而是可以执行其他的任务；

回忆线程任务分为两种：Runnable，Callable

2.1线程池的优点：

降低资源消耗；防止服务器宕机；提高线程的可管理性(约束系统最多几个线程)

2.2线程池的创建

Java中使用ExecutorService (执行者服务创建线程池)

ExecutorService  pools = ExecutorService.newFixedThreadPool(3);

线程池的创建在执行者服务的一个名为newFixedThreadPool() 的静态方法中

线程池创建好了，可以直接向线程池提交任务

pools.submit(task);
//task   只能指 Runnable，Callable类型对象

线程池创建完成后，代码不会挂掉，目的就是为后续服务，就像服务器不会宕机一个意思；

2.3线程池强制关机

pools.shutdown();			//线程池所有任务执行完毕后关机
					
pools.shutdownNow();		//立即关闭线程池，不论线程池所有任务是否完成

关于线程池的方法submit()提交Callable后返回值类型为Future

关于任务，未来任务；获取其内容使用get（）方法

3.死锁

参考操作系统

3.1死锁的四个必要条件

循环等待；互斥使用；不可抢占；请求和保持

记忆方式：	
		线程死锁大多因为资源 请求引起
		-->“请求和保持”的现象 -->线程"循环等待"-->思考是什么原因造成了循环等待-->"资源的互斥使用"，且"不可抢占"
		
		最终：请求和保持 ；循环等待；互斥使用；不可抢占

只要由一个不满足就无法构成死锁，开发必须避免死锁；

3.2写一个必然死锁

    public static void main(String[] args) {

        new Runnable() {
            @Override
            public void run() {
                synchronized (resource01){
                    System.out.println("线程1占用resource01申请resource02");
                    synchronized (resource02){

                    }
                }
            }
        };
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (resource01){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println("线程1占用resource01申请resource02");
                    synchronized (resource02){

                    }
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (resource02){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println("线程2占用resource02申请resource01");
                    synchronized (resource01){

                    }

                }
            }
        }).start();



    }

思路：写两个线程两个资源；
1号资源1号线程占据 
2号资源2号线程占据

1号申请2号资源
2号申请1号资源

获得资源的方式为synchronized(sourece)

为了使必然死锁，每次占据资源后进行sleep(1000)

4.volatile关键字

skill：IDEA的快捷键
ctrl+enter	光标不变，底部扩充

skill: get,set方法

getset方法来说boolean类型是isFlag（）而不是setFlag

volatile关键字使用背景

多个线程访问共享资源，会出现一个线程修改变量的值后，其他线程看不到最新值的情况。

例子如下

原因：

并发编程中，每个子线程都有自己的工作内存

线程对变量所有的读写，操作必须在各自的工作内存中完成，不能直接保存到主内存，
不同线程之间也不能访问对方工作内存的变量；
因此并发编程，多线程修改变量，会出现线程间变量不可见性；

目的是为了提升性能

4.并发编程解决变量不可见性的方式

1.加锁
2.使用volatile关键字修饰变量

4.1加锁方式

加锁的原理

因为上锁的过程为清空工作内存，将主内存变量copy一份到工作内存中，执行代码-->最终 将执行结果copy到主内存中；释放锁；

小结：加锁会清空工作内存，读取主内存中的最新值到工作内存中去

4.2voilatile方式修饰

volatile一旦对变量进行修饰

当子线程对变量进行修改，所有的工作线程都会被通知，你们的变量值失效了，因此所有的工作线程都会去内存取值将其修改；

volatile修饰的变量；当线程对该变量进行修改，主内存变量同步修改，所有的子线程也都会被通知你们的变量失效，需要重新到主内存加载

volatile和synchronized的区别

原子性：就是线程安全
性能上，volatile性能更好