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();
}
}

最新文章

  1. Android中Fragment和ViewPager那点事儿(仿微信APP)
  2. phpmyadmin修改root密码
  3. C#中enum类型
  4. 【leetcode】Minimum Window Substring (hard) ★
  5. 在本地(Eclipse)运行第一个strom-starter例子
  6. Word 录制宏解决粘贴网络上文字格式错乱
  7. 近期刷题的c语言总结。
  8. 关于setLayoutParams报错
  9. ASP.NET 微信支付
  10. Thread Join()的用法
  11. 关于asp:login控件和验证码的问题?(转)
  12. Linux下arp用法
  13. 五、Nginx多Server反向代理配置
  14. java学习开题
  15. linux shell中获取mongodb最大连接数、内存使用情况等
  16. Unix/Linux中的fork函数
  17. 复活广州.net俱乐部
  18. c语言编译四大步
  19. SSM框架mapper.xml模糊查询语句
  20. [工作积累] Google Play Services

热门文章

  1. ios几个重要方法
  2. 优秀开发人员网站推荐。——Arvin
  3. volatile简介
  4. POJ 2096 Collecting Bugs
  5. linux驱动的入口函数module_init的加载和释放【转】
  6. C++ 书籍
  7. Unity Navigation自动寻路
  8. Scrapy的架构初探
  9. Qt的Model/View Framework解析(数据是从真正的“肉(raw)”里取得,Model提供肉,所以读写文件、操作数据库、网络通讯等一系列与数据打交道的工作就在model中做了)
  10. 《Python高效开发实战》实战演练——内置Web服务器4
  11. 【Android Developers Training】 10. 序言:支持不同设备
  12. [国嵌笔记][005][Linux命令详解]
  13. (十二)java嵌套类和内部类
  14. React 学习(一) ---- React Element /组件/JSX
  15. nodejs通过mocha处理运行文件路径下所有js文件
  16. 【HDOJ1069】【动态规划】
  17. 【Selenium-WebDriver自学】Selenium网格化(十六)
  18. 第81讲:Scala中List的构造和类型约束逆变、协变、下界详解
  19. MYSQL数据库封装类
  20. 接口自动化学习--mock