一、概念

1、多个线程之间访问同一资源,进行协调的过程是线程同步。例如两个人同时操作同一银行账户。解决方法:加锁

2、Java种引入对象互斥锁的概念,保证共享数据操作的完整性。每个对象都对应于一个可称为“互斥锁”的标记,这个标记保证在任一时刻,只能有一个线程访问该对象。关键字synchronized来与对象的互斥锁联系。

  当synchronized修饰方法时,是指当前调用该方法的对象被锁定。当synchronized(*)修饰代码块时,*指定的对象被锁定。如果*为this,则与synchronized修饰方法达到的效果一致。

public class Test extends Thread{
public static void main(String args[]){
Test t = new Test();
Test t2 = new Test();
t.start();
t.m2();
}
public synchronized void m1(){
System.out.println("m1");
try{
Thread.sleep(10000);
}catch(Exception e){ }
}
public void m2(){
System.out.println("m2");
try{
Thread.sleep(10000);
}catch(Exception e){
}
}
public void run(){
m1();
}
}

输出:m2m1

public class Test extends Thread{
public static void main(String args[]){
Test t = new Test();
Test t2 = new Test();
t.start();
t.m2();
}
public synchronized void m1(){
System.out.println("m1");
try{
Thread.sleep(10000);
}catch(Exception e){ }
}
public synchronized void m2(){
System.out.println("m2");
try{
Thread.sleep(10000);
}catch(Exception e){
}
}
public void run(){
m1();
}
}

输出:m2 m1

public class Test extends Thread{
public static void main(String args[]){
Test t = new Test();
Test t2 = new Test();
t.start();
t2.start();
t.m2();
t2.m2();
}
public synchronized void m1(){
System.out.println("m1");
try{
Thread.sleep(10000);
}catch(Exception e){ }
}
public synchronized void m2(){
System.out.println("m2");
try{
Thread.sleep(10000);
}catch(Exception e){
}
}
public void run(){
m1();
}
}

输出:m1m1 m2 m2

public class Test extends Thread{
static Object lock=new Object();
public static void main(String args[]){
Test t = new Test();
Test t2 = new Test();
t.start();
t2.start();
t.m2();
t2.m2();
}
public void m1(){
synchronized(lock){
System.out.println("m1");
try{
Thread.sleep(10000);
}catch(Exception e){ }
}
}
public void m2(){
synchronized(lock){
System.out.println("m2");
try{
Thread.sleep(10000);
}catch(Exception e){
}
}
}
public void run(){
m1();
}
}

输出:m1 m1 m2 m2

二、举例

t1,t2两个线程同时访问同一个对象test。

 public class TestSync implements Runnable{
Timer timer = new Timer();
public static void main(String args[]){
TestSync test = new TestSync();
Thread t1 = new Thread(test);
Thread t2 = new Thread(test);
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
}
public void run(){
timer.add(Thread.currentThread().getName());
}
} class Timer{
private static int num = 0 ;
public void add(String name){
synchronized(this){
num++;
try{
Thread.sleep(1);//改成 wait(100);不行,因为wait释放锁
}catch(InterruptedException e){
}
System.out.println(name+",你是第"+num+"个使用timer的线程");
}
}
}

输出:

t1,你是第1个使用timer的线程
t2,你是第2个使用timer的线程

如果去掉synchronized则输出错误:

t2,你是第2个使用timer的线程
t1,你是第2个使用timer的线程

错误原因:一个线程的执行过程中,被另一个线程打断了。

解决方法一:在20行加入synchoronized互斥锁(上面的代码)。因为synchoronized锁定的是当前对象,而

Thread t1 = new Thread(test);
Thread t2 = new Thread(test);

所以能够达到同步效果,因为t1,t2是同一个test对象,对应的timer也是同一个。如果

Thread t1 = new Thread(test1);
Thread t2 = new Thread(test2);

则不能达到同步效果,因为t1,t2不是同一对象,对应的timer不是同一个。

package test2;
public class TestSync implements Runnable{
static Timer timer = new Timer();
public static void main(String args[]){
TestSync test = new TestSync();
TestSync test2 = new TestSync();
Thread t1 = new Thread(test);
Thread t2 = new Thread(test2);
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
}
public void run(){
timer.add(Thread.currentThread().getName());
}
} class Timer{
private static int num = 0 ;
public synchronized void add(String name){
num++;
try{
Thread.sleep(3000);//改成 wait(100);不行,因为wait释放锁
}catch(InterruptedException e){
}
System.out.println(name+",你是第"+num+"个使用timer的线程");
}
}

输出正确,因为timer是同一个对象。

解决方法二:或者在19行加入同步方法。如下:

public class TestSync implements Runnable{
Timer timer = new Timer();
public static void main(String args[]){
TestSync test = new TestSync();
Thread t1 = new Thread(test);
Thread t2 = new Thread(test);
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
}
public void run(){
timer.add(Thread.currentThread().getName());
}
} class Timer{
private static int num = 0 ;
public synchronized void add(String name){
//synchronized(this){
num++;
try{
Thread.sleep(1);
}catch(InterruptedException e){
}
System.out.println(name+",你是第"+num+"个使用timer的线程");
//}
}
}

注意调用sleep的线程不释放锁,但调用wait的线程释放锁。

三、死锁的模拟

public class TestDeadLock implements Runnable{
public int flag = 1 ;
static Object o1 = new Object();
static Object o2 = new Object();
public void run(){
System.out.println("flag="+flag);
if(flag==1){
synchronized(o1){
try{
Thread.sleep(500);
}catch(Exception e){
e.printStackTrace();
}
synchronized(o2){
System.out.println("1");
}
}
}
if(flag==0){
synchronized(o2){
try{
Thread.sleep(500);
}catch(Exception e){
e.printStackTrace();
}
synchronized(o1){
System.out.println("0");
}
}
}
}
public static void main(String[] args){
TestDeadLock t1 = new TestDeadLock();
TestDeadLock t2 = new TestDeadLock();
t1.flag = 1 ;
t2.flag = 0 ;
Thread t11 = new Thread(t1);
Thread t22 = new Thread(t2);
t11.start();
t22.start();
}
}

死锁的条件(四个同时满足):互斥、部分锁定、循环等待、不可剥夺

解决方法:锁的粒度加粗(一次性锁定全部需要的资源,破坏部分锁定)

     规定顺序(破坏循环等待)

       可以剥夺(破坏不可剥夺)

四、synchronized面试题

(1)

问:上面程序中一个线程调用m1方法时,另一个线程可以同时调用m2方法吗?

答案:可以同时执行。main()函数运行输出1000,b=1000,说明可以同时执行两个方法。(如果输出100,b=1000则说明不可以)。如果将m2方法改为:

结果又是什么呢?答案:可以同时执行。输出2000,b=2000。

执行过程:m1修改b为1000,之后睡眠,m2修改b为2000,main中打印2000,m1睡眠结束打印b=2000。

注:那个方法加了synchronized只是说明该方法同时可以被一个线程调用,但是其他线程仍然可以自由调用非同步的方法(可能对同步方法产生影响,例如涉及到该同步方法中的变量)。

(2)正确做法:m1,m2都加同步

所以说,b相当于一个资源,如何控制该资源能够被正确访问呢?这就需要把涉及到该资源b的所有方法都考虑到!哪些方法是不是要设置为synchronized,所以本题中需要把m1,m2方法都加锁,即用synchronized修饰为同步方法。如下:

结果又是什么?答案:输出1000,b=1000

执行过程:m1,m2不能同时执行。运行m2方法,b的值改为2000,之后运行m1方法输出b改为1000,m1睡眠,main主线程输出1000,m1方法输出b=1000。

5、两个方法一个读该对象,另一个修改该对象的值。一般的情况下改的方法加锁(同步方法),因为不允许多个线程同时改;读的方法不加锁(非同步方法),因为可以同时读。所以是加只读锁。

      

JAVA笔记15-线程同步的更多相关文章

  1. java笔记--关于线程同步(7种同步方式)

    关于线程同步(7种方式) --如果朋友您想转载本文章请注明转载地址"http://www.cnblogs.com/XHJT/p/3897440.html"谢谢-- 为何要使用同步? ...

  2. java笔记--关于线程同步(5种同步方式)【转】

    为何要使用同步?     java允许多线程并发控制,当多个线程同时操作一个可共享的资源变量时(如数据的增删改查),      将会导致数据不准确,相互之间产生冲突,因此加入同步锁以避免在该线程没有完 ...

  3. java笔记--关于线程同步(5种同步方式)

    转自:http://www.2cto.com/kf/201408/324061.html 为何要使用同步?     java允许多线程并发控制,当多个线程同时操作一个可共享的资源变量时(如数据的增删改 ...

  4. 关于Java多线程的线程同步和线程通信的一些小问题(顺便分享几篇高质量的博文)

    Java多线程的线程同步和线程通信的一些小问题(顺便分享几篇质量高的博文) 前言:在学习多线程时,遇到了一些问题,这里我将这些问题都分享出来,同时也分享了几篇其他博客主的博客,并且将我个人的理解也分享 ...

  5. Java中的线程同步

    Java 中的线程同步问题: 1. 线程同步: 对于访问同一份资源的多个线程之间, 来进行协调的这个东西. 2. 同步方法: 当某个对象调用了同步方法时, 该对象上的其它同步方法必须等待该同步方法执行 ...

  6. Java并发包——线程同步和锁

    Java并发包——线程同步和锁 摘要:本文主要学习了Java并发包里有关线程同步的类和锁的一些相关概念. 部分内容来自以下博客: https://www.cnblogs.com/dolphin0520 ...

  7. Java多线程 3 线程同步

    在之前,已经学习到了线程的创建和状态控制,但是每个线程之间几乎都没有什么太大的联系.可是有的时候,可能存在多个线程多同一个数据进行操作,这样,可能就会引用各种奇怪的问题.现在就来学习多线程对数据访问的 ...

  8. java中实现线程同步

    为何要使用同步? java允许多线程并发控制,当多个线程同时操作一个可共享的资源变量时(如数据的增删改查), 将会导致数据不准确,相互之间产生冲突,因此加入同步锁以避免在该线程没有完成操作之前,被其他 ...

  9. java并发:线程同步机制之Volatile关键字&原子操作Atomic

    volatile关键字 volatile是一个特殊的修饰符,只有成员变量才能使用它,与Synchronized及ReentrantLock等提供的互斥相比,Synchronized保证了Synchro ...

  10. Java高级之线程同步

    本文来自http://blog.csdn.net/liuxian13183/ ,引用必须注明出处! 关于实现多线程的意义,"从业四年看并发"一文已经讲述,而本篇主要讲一下常用的设计 ...

随机推荐

  1. c++ 引用 日期&时间

    日期时间[点击进入看吧,没啥可后期拓展的] 引用 引用变量是一个别名,也就是说,它是某个已存在变量的另一个名字.一旦把引用初始化为某个变量,就可以使用该引用名称或变量名称来指向变量. 一.引用和指针的 ...

  2. Unity中的动画系统和Timeline(4) AvatarMask和IK动画

    AvatarMask(骨骼遮罩) 在前面角色动画的基础上,角色在奔跑过程中捡起一块木头,双手要抱着这块木头.如果使用前面的方法,直接切换动画,那么就只剩下抱木头的动画,其它动画就没了.这时我们要使用下 ...

  3. P1596 【[USACO10OCT]湖计数Lake Counting】

    可爱的题面君~~ 个人感觉这题还是很简单的,就是一个完全不加工的找联通块个数 个人解题思路是先读入,然后循环一遍,遇到水就dfs,并把这个w所在的联通块“删除”,并在答案上加一 最后输出答案 具体注释 ...

  4. 《Python编程从0到1》笔记4——你分得清“索引和切片”吗?

    Python为序列类型(sequence types)[1]提供了独特的索引(indexing)和切片(slicing)机制以访问序列的某个元素或某一部分. [1] 如list, tuple, ran ...

  5. vue中,基于echarts 地图实现一个人才回流的大数据展示效果

    0.引入echarts组件,和中国地图js import eCharts from 'echarts' import 'echarts/map/js/china.js'// 引入中国地图 1. 设置地 ...

  6. 最新的省市编码和sql

    下面的项目是整理的最新的省市编码sql文件,可以看看. github

  7. 2019JAVA第五次实验报告

    Java实验报告 班级 计科二班 学号 20188442 姓名 吴怡君 完成时间2019/10/11 评分等级 实验四 类的继承 实验目的 理解抽象类与接口的使用: 了解包的作用,掌握包的设计方法. ...

  8. 小记---------FLUM负载均衡配置

    sink group允许组织多个sink到一个实体上,sink processors能够提供在组内所有sink之间实现负载均衡的能力,而且在失败的情况下能够进行故障转移从一个sink到另一个sink, ...

  9. Luogu P3942 将军令

    题目 维护每个点子树中最深的没有被覆盖的点(仅计算这条链上的关键点)的距离. 若\(u\)为关键点,则\(d_u=-k-1\). 记录\(mx=\max\limits_{v\in son_u}d_v+ ...

  10. pythonWeb框架创建app模块以及虚拟环境管理工具

    在进行项目搭建的时候,如果有多个功能模块,以及多个网页地址时,为了系统的可维护性,以及易读性,我们大多数情况下选择模块化开发 所以我们就要使用app指令来创建不同的功能模块 首先项目框架如下: 接下来 ...