1.同一个资源,同步和非同步的方法可以同时调用
package com.dingyu; public class Y { public synchronized void m1() { System.out.println(Thread.currentThread().getName() + " m1 begin---------"); try { Thread.sleep(5000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " m1 end---------"); } public void m2() { System.out.println(Thread.currentThread().getName() + " m2 begin---------"); try { Thread.sleep(5000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " m2 end---------"); } public static void main(String[] args) { Y t = new Y(); // new Thread(()->t.m1(),"t1").start(); // new Thread(()->t.m2(),"t2").start(); new Thread(new Runnable() { @Override public void run() { t.m1(); } },"t1").start();; new Thread(new Runnable() { @Override public void run() { t.m2(); } },"t2").start();; } }
可以看到t1先执行,如果不能同时调用那么t2是不能执行的,必须等t1结束,释放锁后才能调用,但这里t2确先执行了,所以是可以同时调用的。
2.对业务写代码进行加锁,对读代码不进行加锁,会产生脏读
package com.dingyu; public class U { private String name; private double banlance; public synchronized void set(String name, double balance) { this.name = name; try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } this.banlance = balance; } public double getBalance() { return banlance; } public static void main(String[] args) { U u = new U(); new Thread(() -> u.set("zhangsan", 500)).start(); System.out.println(u.getBalance()); try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(u.getBalance()); } }
3.同线程内一个同步方法可以去调用另一个同步方法(重入锁 还有一种重入锁就是子类调用父类的同步方法)
package com.dingyu; public class I { public synchronized void m1() { System.out.println("m1 start"); m2(); System.out.println("m1 end"); } private synchronized void m2() { System.out.println("m2 start"); System.out.println("m2 end"); } public static void main(String[] args) { I i = new I(); new Thread(() -> i.m1()).start(); } }
4.模拟一个简单的死锁
package com.dingyu; public class DeadLock { private Object o1 = new Object(); private Object o2 = new Object(); public void m1() { synchronized (o1) { try { Thread.sleep(10000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (o2) { System.out.println("如果出现这句话表示没有死锁"); } } } public void m2() { synchronized(o2) { synchronized (o1) { System.out.println("如果出现这句话表示没有死锁"); } } } public static void main(String[] args) { DeadLock deadLock=new DeadLock(); new Thread(()->deadLock.m1()).start(); new Thread(()->deadLock.m2()).start(); } }
5.如果执行同步方法中出现异常,那么就会自动释放锁,如果不想释放锁,加上try catch
package com.dingyu; public class ReleaseLock { private int count = 0; private int i = 0; public synchronized void m1() { while (true) { System.out.println(Thread.currentThread().getName() + " " + count++); if (count % 10 == 0) i = 1 / 0; } } public static void main(String[] args) { ReleaseLock releaseLock = new ReleaseLock(); new Thread(() -> releaseLock.m1(), "t1").start(); new Thread(() -> releaseLock.m1(), "t2").start(); } }
6.volatile关键字(无锁同步)
volatile关键字 每个线程都有自己的一小块内存,执行的时候会把变量copy过来,修改了后在写回对象,
执行m1方法的线程把 running读到内存里,与此同时主线程也把running读到内存,并进行修改,写回对象为false
但是执行m1的线程里的内存一直都是true啊(因为太忙了没空去刷新)所以会形成死循环,
volatile就是当running改了之后 *立马去通知其他线程,你们记得去主存刷新一下,一刷新,running为false,退出while循环。
package com.dingyu; /** * volatile关键字 每个线程都有自己的一小块内存,执行的时候会把变量copy过来,修改了后在写回对象, * 执行m1方法的线程把 running读到内存里,与此同时主线程也把running读到内存,并进行修改,写回对象为false * 但是执行m1的线程里的内存一直都是true啊(因为太忙了没空去刷新)所以会形成死循环,volatile就是当running改了之后 * 立马去通知其他线程,你们记得去主存刷新一下,一刷新,running为false,退出while循环。 * @author dingyu * */ public class VolatileDemo { private volatile boolean running = true; public void m1() { System.out.println("m1 start"); while (running) { } System.out.println("m1 end"); } public static void main(String[] args) { VolatileDemo volatileDemo = new VolatileDemo(); new Thread(() -> volatileDemo.m1()).start(); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } volatileDemo.running = false; } }
7.voliatile 不能保证原子性 不能替换synchronized
package com.dingyu; /** * voliatile 不能保证原子性 不能替换synchronized * * @author dingyu * */ public class VolatileDemo02 { public volatile int count = 0; public void m1() { for (int i = 0; i <= 10000; i++) count++; } public static void main(String[] args) { VolatileDemo02 volatileDemo02 = new VolatileDemo02(); for (int i = 0; i < 3; i++) { new Thread(() -> volatileDemo02.m1()).start(); } try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(volatileDemo02.count); } }
8.多个原子类的方法之间不具备原子性
package com.dingyu; import java.util.concurrent.atomic.AtomicInteger; /** * 原子类 具有原子性,但两个原子类的方法之间不具备原子性 * * @author dingyu * */ public class AtomicDemo { private AtomicInteger count = new AtomicInteger(); public void m1() { for (int i = 0; i < 100; i++) { count.incrementAndGet(); //两个原子类的方法之间不具备原子性 count.incrementAndGet(); } } }
9.原子类的不具备可见性
package com.dingyu; import java.util.concurrent.atomic.AtomicBoolean; public class AtomicDemo02 { public AtomicBoolean running = new AtomicBoolean(true); public void m1() { while (running.get()) { } } public static void main(String[] args) { AtomicDemo02 demo02 = new AtomicDemo02(); new Thread(()->demo02.m1()).start(); demo02.running.set(false); } }
10.锁是锁在堆内存的那个对象上,而不是引用
package com.dingyu; /** * 锁是锁在堆内存的那个对象上,而不是引用 * * @author dingyu * */ public class ChangeReference { public Object o = new Object(); public void m1() { //锁o synchronized (o) { while (true) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()); } } } public static void main(String[] args) { ChangeReference changeReference = new ChangeReference(); new Thread(() -> changeReference.m1(), "t1").start();//启动一个线程 叫t1 try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } changeReference.o = new Object();//引用变了 new Thread(() -> changeReference.m1(),"t2").start();//启动线程 t2 } }
11.不要锁字符串常量
package com.dingyu; /** * 不要锁字符串常量 * @author dingyu * */ public class SynchronizedString { private String s1 = "hello"; private String s2 = "hello"; public void m1() { synchronized (s1) { while(true) {} } } public void m2() { synchronized (s2) { System.out.println("m2 start"); } } public static void main(String[] args) { SynchronizedString synchronizedString = new SynchronizedString(); new Thread(()->synchronizedString.m1()).start(); new Thread(()->synchronizedString.m2()).start(); } }
12.wait 让线程暂停,释放锁, notify 唤醒线程,不释放锁
package com.dingyu2; /** * wait 让线程暂停,释放锁, notify 唤醒线程,不释放锁 * * @author dingyu * */ public class WaitAndNotyifyDemo { private volatile int count = 0; private Object lock = new Object(); public void m1() { synchronized (lock) { System.out.println("m1 start"); for (int i = 0; i < 10; i++) { count++; System.out.println(count); if (count == 5) { lock.notify(); try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } } } public void m2() { synchronized (lock) { System.out.println("m2 start"); if (count != 5) { try { System.out.println("m2 在等着 但把锁释放了"); lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("m2 end"); lock.notify(); } } public static void main(String[] args) { WaitAndNotyifyDemo waitAndNotyifyDemo = new WaitAndNotyifyDemo(); new Thread(() -> waitAndNotyifyDemo.m2()).start(); new Thread(() -> waitAndNotyifyDemo.m1()).start(); } }