synchronized同步关键字
/**
* synchronized关键字:对某个对象加锁。
* 是原子操作,不可分:原子操作是指不会被线程调度机制打断的操作;这种操作一旦开始,就一直运行到结束。
* @author zhouyi
*
*/
public class Synchronized {
private int count = 10;
private Object object;
public void Synchronized() {
object = new Object();
// 举例:有两个线程,第一个线程,已经拿到了object的锁,运行到方法之中,那么第二个线程进来时拿不到的
synchronized (object) { // 任何线程想要执行下面的代码,必须先要拿到object的锁。
count--;
System.out.println(Thread.currentThread().getName() + "count:" + count);
}
}
}
常用写法:当运行时。首先锁定自身,在执行(注意:不是锁的代码块,而是运行时锁定当前对象,可指定)
同样(推荐使用)
静态加锁。
/**
* synchronized关键字:对某个对象加锁。
* @author zhouyi
*
*/
public class Synchronized {
private static int count = 10;
public synchronized static void syn() {// 等同于synchronized(this)
count--;
System.out.println(Thread.currentThread().getName() + "count:" + count);
}
public static void Sync() {
synchronized(Synchronized.class) { // 静态可以直接访问,是不需要new的,因此不可使用this
count++;
}
}
}
同步方法和非同步方法的可以同时调用。
public class Synchronized {
public synchronized void syn() {
System.out.println(Thread.currentThread().getName() + "thread1.start");
try {
Thread.sleep(3000);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "thread1.end");
}
public void Sync() {
try {
Thread.sleep(1500);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "thread2");
}
public static void main(String[] args){
Synchronized synchronized1 = new Synchronized();
new Thread(()->synchronized1.syn(), "t1").start(); // t1为线程取名,这是java8的lamda表达式
new Thread(()->synchronized1.Sync(),"t2").start();
/**
*或者用java8里面number表达式
*new Thread(synchronized1 : syn(), "t1").start();
*new Thread(synchronized1 : Sync(),"t2").start();
*/
}
}
运行结果:
脏读问题:
/**
* 对业务写方法加锁,对业务读方法加锁
* 容易产生脏读问题(dirtyRead)
* @author zhouyi
*
*/
public class Acount {
String name;
double banlance;
public synchronized void set(String name, double banlance) {
this.name = name;
try { // 为了看到现象特意设定;体现出线程之间的时间差,从而导致问题
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 在这两者之间,读入getBanlance,就会导致脏读。
this.banlance = banlance;
}
public double getBanlance(String name) {// 通过人名,拿到账户余额
return this.banlance;
}
public static void main(String[] s) {
Acount acount = new Acount();
new Thread(()->acount.set("zhouyi", 1000)).start();
try {
TimeUnit.SECONDS.sleep(1);// TimeUnit提供了可读性更好的线程暂停操作,通常用来替换Thread.sleep()
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(acount.getBanlance("zhouyi"));
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(acount.getBanlance("zhouyi"));
}
}
运行结果:
同步方法调用另一个同步方法,一个线程已经拥有了某个对象的锁,在此申请依然看可以得到该对象的锁。
所以synchronized的锁是可以重入的
synchronized 使用的注意事项:
1,不要以字符串常量作为锁定对象。比如,String str1 = “zhouyi”;String str2 = “zhouyi”;使用synchronized 去加锁,其实liang’z两者是同一个锁“zhouyi”
volatile关键字:线程之间的可见性
作用:是一个变量在多个线程中可见(保证一个线程中改了,其他线程也改了)
对volatile的利用例子:
/**
* 实现一个容器,提供两个方法add,size
* 编写两个线程,线程1添加10个元素,线程2实现监控元素的个数,当个数达到第五个时,
* 线程2给出提示并结束
*
* wait,notify
* @author zhouyi
*
*/
public class T {
volatile static List list = new ArrayList<>();
/**
* 添加元素
*/
public void add(Object object){
list.add(object);
}
/**
* 判断大小
*/
public int size(List list){
return list.size();
}
public static void main(String[] aStrings) {
T t = new T();
new Thread(()->{
for (int i = 0; i < 10; i++){
t.add(new Object());
System.out.println("添加第:" + i);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"thread1").start();
new Thread(()->{
while (true) {
if (t.size(list) == 5) {
break;
}
}
System.out.println("th2结束");
},"thread2").start();
}
}
运行结果:发现结果5-6并不是我们想要的
synchronized和volatile的区别:
一旦一个共享变量(类的成员变量、类的静态成员变量)被volatile修饰之后,那么就具备了两层语义:
1)保证了不同线程对这个变量进行操作时的可见性,即一个线程修改了某个变量的值,这新值对其他线程来说是
立即可见的。
2)禁止进行指令重排序。
volatile本质是在告诉jvm当前变量在寄存器(工作内存)中的值是不确定的,需要从主存中读取;
synchronized则是锁定当前变量,只有当前线程可以访问该变量,其他线程被阻塞住。
1.volatile仅能使用在变量级别;
synchronized则可以使用在变量、方法、和类级别的
2.volatile仅能实现变量的修改可见性,并不能保证原子性;
synchronized则可以保证变量的修改可见性和原子性
3.volatile不会造成线程的阻塞;
synchronized可能会造成线程的阻塞。
4.volatile标记的变量不会被编译器优化;
synchronized标记的变量可以被编译器优化。
原子变量:Atomic
讲到多线程就不得不讲到原子变量,而不用比如i++这种不具备原子性的
wait,notify对
wait会释放锁,notify不会释放锁(sleep也不会释放锁),简单来说:wait和notify这两个方法是一对,wait方法阻塞当前线程,而notify是唤醒被wait方法阻塞的线程。
waitAll和notify,是让当前对象所有的方法,阻塞或唤醒。
利用wait和notify,来避免上面的while,死循环,避免资源浪费。具体例子:
/**
* 实现一个容器,提供两个方法add,size
* 编写两个线程,线程1添加10个元素,线程2实现监控元素的个数,当个数达到第五个时,
* 线程2给出提示并结束
*这里thread2必须执行,进入等待状态。
* wait,notify
* @author zhouyi
*
*/
public class T {
volatile static List list = new ArrayList<>();
/**
* 添加元素
*/
public void add(Object object){
list.add(object);
}
/**
* 判断大小
*/
public int size(List list){
return list.size();
}
public static void main(String[] aStrings) {
T t = new T();
final Object lock = new Object();
new Thread(()->{
synchronized (lock) {
System.out.println("thread2开始");
if (t.size(list) != 5) {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.out.println("thread2结束");
},"thread2").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
System.out.println("thread1开始");
synchronized (lock) {
for (int i = 0; i < 10; i++){
t.add(new Object());
System.out.println("添加第:" + i);
if (t.size(list) == 5) {
lock.notify();
}
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
},"thread1").start();
}
}
运行结果:结果也不是我们所要的,到5并没有结束。这是因为notify不释放锁所造成。
解决方法:
这样的方法显然显得很不方便。
最好的解决方式(用门闩(Latch)代替wait和notify进行通知,利用await和countDown),实例:
/**
* 实现一个容器,提供两个方法add,size
* 编写两个线程,线程1添加10个元素,线程2实现监控元素的个数,当个数达到第五个时,
* 线程2给出提示并结束
*采用门闩(Latch)代替wait和notify进行通知,利用await和countDown
* wait,notify
* @author zhouyi
*
*/
public class T {
volatile static List list = new ArrayList<>();
/**
* 添加元素
*/
public void add(Object object){
list.add(object);
}
/**
* 判断大小
*/
public int size(List list){
return list.size();
}
public static void main(String[] aStrings) {
T t = new T();
// 当门闩到0时,门闩就开了
CountDownLatch latch = new CountDownLatch(1);
new Thread(()->{
System.out.println("thread2开始");
if (t.size(list) != 5) {
try {
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("thread2结束");
},"thread2").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
System.out.println("thread1开始");
for (int i = 0; i < 10; i++){
t.add(new Object());
System.out.println("添加第:" + i);
if (t.size(list) == 5) {
latch.countDown();
}
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"thread1").start();
}
}