Java基础笔记 – 线程同步问题 解决同步问题的方法 synchronized方法 同步代码块
本文由发表于6年前 | Java基础 | 评论数 5 |  被围观 18,250 views+
1、多线程的同步:1.1、同步机制:1.2、共享成员变量的例子:成员变量与局部变量:下面举例说明:1.3、共享资源导致的读取错误2、同步机制的实现:2.1、使用synchronized关键字创建synchronized方法:静态的synchronized方法调用情况:2.2、使用synchronized创建同步代码块:2.3、synchronized方法和synchronized同步代码块的区别:
1、多线程的同步:
1.1、同步机制:

在多线程中,可能有多个线程试图访问一个有限的资源,必须预防这种情况的发生。所以引入了同步机制:在线程使用一个资源时为其加锁,这样其他的线程便不能访问那个资源了,直到解锁后才可以访问。

1.2、共享成员变量的例子:
成员变量与局部变量:

成员变量:

如果一个变量是成员变量,那么多个线程对同一个对象的成员变量进行操作,这多个线程是共享一个成员变量的。

局部变量:

如果一个变量是局部变量,那么多个线程对同一个对象进行操作,每个线程都会有一个该局部变量的拷贝。他们之间的局部变量互不影响。

下面举例说明:

实现了Runnable的线程类:

class MyThread3 implements Runnable{

    //两个线程操作同一个对象,共享成员变量
    //int i;
    @Override
    public void run() {
        //两个线程操作同一个对象,各自保存局部变量的拷贝
        int i = 0;
        while(i<100){
            System.out.println(i);
            i++;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在main方法中用两个线程操作同一个对象:

public static void main(String[] args) {

    MyThread3 myThread = new MyThread3();
    //下面两个线程对同一个对象(Runnable的实现类对象)进行操作
    Thread thread = new Thread(myThread);
    Thread thread2 = new Thread(myThread);
    //各自保存局部变量的拷贝,互不影响,输出200个数字
    thread.start();
    thread2.start();
}

这里如果把i变成成员变量,则输出100个数字。

1.3、共享资源导致的读取错误

下面举个例子,两个线程共用一个Number对象,通过Number类的getNumber方法获取数据,读取数据并改写时,发现了重复读操作:

首先创建一个Number类:

class Number{
    private int number = 10;
    public String getNumber(int i){
        if(number > 0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            number -= i;
            return "取出"+i+"成功,剩余数量:"+number;
        }
        return "取出"+i+"失败,剩余数量:"+number;
    }
}

线程类,在线程类中的私有属性包含了Number类的引用:

class MyThread4 extends Thread{

    //两个线程操作同一个对象,共享成员变量
    Number number;
    public MyThread4(Number number){
        this.number = number;
    }
    @Override
    public void run() {
        System.out.println(number.getNumber(8));
    }
}

在main函数中创建两个线程类,包含了同一个Number类实例的引用:

public static void main(String[] args) {

    Number number = new Number();
    //两个线程操作同一个对象,共享对象number的成员变量number
    MyThread4 myThread = new MyThread4(number);
    MyThread4 myThread2 = new MyThread4(number);
    myThread.start();
    myThread2.start();
}

这样,当第一个线程读取Number中的number变量时先保存下来再休眠0.1秒,然后第二个线程再读取number变量并保存,此时两个线程保存了同样的数字,在修改时,也就导致修改了同一个数字两次。

2、同步机制的实现:
2.1、使用synchronized关键字创建synchronized方法:

使用synchronized关键字,该关键字修饰的方法叫做同步方法。

Java中每个对象都有一个锁或者称为监视器,当访问某个对象的synchronized方法时,表示将该对象上锁,而不仅仅是为该方法上锁。

这样如果一个对象的synchronized方法被某个线程执行时,其他线程无法访问该对象的任何synchronized方法(但是可以调用其他非synchronized的方法)。直至该synchronized方法执行完。

静态的synchronized方法调用情况:

当调用一个对象的静态synchronized方法时,它锁定的并不是synchronized方法所在的对象,而是synchronized方法所在对象对应的Class对象。这样,其他线程就不能调用该类的其他静态synchronized方法了,但是可以调用非静态的synchronized方法。

结论:执行静态synchronized方法锁方法所在对象,执行非静态synchronized方法锁方法所在对象对应的Class对象。

下面是多线程调用静态的方法的例子,由于锁定了方法所在对象对应的Class对象,其他线程无法调用该方法所在对象其他的静态synchronized方法:

/**
 * 定义一个类,包含了线程类需要调用的方法
 */
class Compute1{
    //这时如果某个线程调用该方法,
    //将锁定synchronized方法所在对象对应的class对象,
    //而不是锁定synchronized方法所在对象
    public synchronized static void execute(){
        for(int i = 0; i<100; i++){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("compute1:execute1 " + i++);
        }
    }
    public synchronized static void execute2(){
        for(int i = 0; i<100; i++){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("compute1:execute2 " + i++);
        }
    }
}

main方法中两个线程分别调用同一个对象的两个static synchronized方法:

public static void main(String[] args) {
    Compute1 com = new Compute1();
    Thread thread1 = new Thread1(com);
    Thread thread2 = new Thread2(com);
    thread1.start();
    thread2.start();
}

一次只能调用一个静态方法,直到执行完成。

2.2、使用synchronized创建同步代码块:

通过使用synchronized同步代码块,锁定一个对象,该对象作为可执行的标志从而达到同步的效果:

/**
 * 定义一个类,包含了线程类需要调用的方法
 */
class Compute1{
    //通过同步代码块锁定object1对象进行锁定了其他同样的synchronized代码块
    private Object object1 = new Object();
    public void execute(){
        synchronized(object1){
            for(int i = 0; i<100; i++){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("compute1:execute1 " + i++);
            }
        }

    }
    public synchronized void execute2(){
        synchronized(object1){
            for(int i = 0; i<100; i++){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("compute1:execute2 " + i++);
            }
        }
    }
}

如果想要使用synchronized同步代码块达到和使用synchronized方法同样的效果,可以锁定this引用:

synchronized(this){
    …
}
2.3、synchronized方法和synchronized同步代码块的区别:

synchronized同步代码块只是锁定了该代码块,代码块外面的代码还是可以被访问的。

synchronized方法是粗粒度的并发控制,某一个时刻只能有一个线程执行该synchronized方法。

synchronized同步代码块是细粒度的并发控制,只会将块中的代码同步,代码块之外的代码可以被其他线程同时访问。

除了文章中有特别说明,均为IT宅原创文章,转载请以链接形式注明出处。
本文链接:http://www.itzhai.com/java-based-notebook-thread-synchronization-problem-solving-synchronization-problems-synchronized-block-synchronized-methods.html
关键字: , , ,
arthinking Java技术交流群:280755654,入门群:428693174 more
分享到:
 
2011 10/24
文章评论
    5条评论
  1. 红色石头 2013年03月26日13:19:56  #-49楼 回复 回复

    mark一下,博主可以整理一下关于线程同步的所有方法~

  2. Ranger 2014年09月06日10:13:14  #-48楼 回复 回复

    1.3这个例子建议用 if(number > 5) 作判断条件会比较容易理解。这样就可以看出在加和不加synchronized关键字的情况下,两个thread输出结果的不同表现了。

  3. xinwendashibaike 2015年01月12日09:43:41  #-47楼 回复 回复

    这样,当第一个线程读取Number中的number变量时先保存下来再休眠0.1秒,然后第二个线程再读取number变量并保存,此时两个线程保存了同样的数字,在修改时,也就导致修改了同一个数字两次。
    看不懂这句话,表述成:线程1通过if判断,开始休眠,同时线程2也通过if判断,也开始休眠,线程1休眠结束,修改number,线程2也休眠结束,修改numer

给我留言

有人回复时邮件通知我
Java基础的相关文章
随机文章 本月热门 热评
1 JVM笔记 – 高效并发(线程安全与锁优化) 2015/3/2
2 连接不上Internet,那让局域网更丰富吧 2012/5/22
3 Javascript中的for in语句获取对象属性的顺序问题 2012/8/16
4 Android中使用Animation实现控件的动画效果以及Interpolator和AnimationListener的使用 2011/7/14
5 Hibernate一对多关联映射的配置及其级联删除问题 2011/5/26
6 纯Javascript打造的红色玫瑰花 1k Rose 2012/2/13
友情推荐 更多
破博客 文官洗碗安天下,武将打怪定乾坤。多么美好的年代,思之令人泪落。
Mr.5's Life 白天是一名程序员,晚上就是个有抱负的探索者
行知-追寻技术之美 关注大数据,分布式系统
我爱编程 编程成长轨迹
Cynthia's Blog 学习笔记 知识总结 思考感悟
 
猜您喜欢
欢迎关注我的公众号 IT宅
关于IT宅 文章归档

IT宅中的文章除了标题注明转载或有特别说明的文章,均为IT宅的技术知识总结,学习笔记或随笔。如果喜欢,请使用文章下面提供的分享组件。转载请注明出处并加入文章的原链接。 感谢大家的支持。

联系我们:admin@itzhai.com

Theme by arthinking. Copyright © 2011-2015 IT宅.com 保留所有权利.