并发编程系列小结（线程安全，synchronized，脏读，线程间的通信wait/notify，线程的三种实现方式Demo，可替代wait/notify的方法）

线程安全：

当多个线程访问某一个类（对象或方法）时，这个类始终都能表现出正确的行为，那么这个类（对象或方法就是线程安全的）

synchronized：

可以在任意对象或方法上加锁，而加锁的这段代码称为“互斥区”或“临界区”

多个线程多个锁：

多个线程都有自己对应的锁

 

脏读：

在我们对一个对象的方法或对象加锁时，需要考虑业务的整体性，即为setValue/getValue方法同时加锁synchronized同步关键字，保证业务的原子性，不然会出现业务错误（也从侧面保证了数据的一致性）

线程间的通信：

使用notify/wait方法实现线程间的通信（注意这两个方法都是object类的方法）

wait/ notify 必须配合synchronized关键字使用

wait方法释放锁，notify方法不释放锁

CountDownLatch与锁无关

线程的三种实现方式Demo

package com.jonychen.test;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * 线程的三种实现方式
 */
public class TestDemo {

    public static void main(String[] args){
     /**
         * 第一种方式：继承Thread类重写run()方法
         */
        Thread thread=new ThreadDemo();
        thread.start();

        /**
         * 第二种方式：实现Runnable接口重写run()方法
         */
        RunnableDemo runnableDemo=new RunnableDemo();
        Thread thread1=new Thread(runnableDemo);
        thread1.start();
        try {
            thread1.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        /**
         * 第三种方式：实现Callable接口重写call()方法
         */
        CallableDemo  callableDemo =new CallableDemo();
        FutureTask<Integer> futureTask=new FutureTask<Integer>(callableDemo);
        Thread thread2=new Thread(futureTask);
        thread2.start();
        try {
            System.out.println("返回的参数为："+futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

/**
 * 第一种方式：继承Thread类重写run()方法
 */
class ThreadDemo extends Thread{
    @Override
    public void run() {
        System.out.println("我是继承Thread类实现线程的一种方式！");
    }
}

/**
 * 第二种方式：实现Runnable接口重写run()方法
 */
class  RunnableDemo implements  Runnable{
    @Override
    public void run() {
        System.out.println("我是实现Runnable接口实现线程的一种方式");
    }
}

/**
 * 第三种方式：实现Callable接口重写call()方法
 */
class  CallableDemo implements Callable<Integer>{

    @Override
    public Integer call(){
        return 666666;
    }
}

输出截图：

可替代wait/notify的方法

package com.jonychen.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 *java.util.concurrent 类库中提供了 Condition 类来实现线程之间的协调，可以在 Condition 上调用 await() 方法使线程等待，
 * 其它线程调用 signal() 或 signalAll() 方法唤醒等待的线程。
 * 相比于 wait() 这种等待方式，await() 可以指定等待的条件，因此更加灵活。
 *
 * 使用 Lock 来获取一个 Condition 对象。
 */
public class ConcurrentDemo {

    private Lock lock=new ReentrantLock();
    private Condition condition=lock.newCondition();

    public  void before(){
        lock.lock();
        try {
            System.out.println("before");
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public  void after(){
       lock.lock();
        try {
            condition.await();
            System.out.println("after");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    public static void main(String[] args){

        ExecutorService executorService  =Executors.newCachedThreadPool();
        ConcurrentDemo concurrentDemo=new ConcurrentDemo();
        executorService.execute(()->concurrentDemo.after());
        executorService.execute(()->concurrentDemo.before());
    }

}