线程安全：
当多个线程访问某一个类（对象或方法）时，这个类始终都能表现出正确的行为，那么这个类（对象或方法就是线程安全的）
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());
} }
