同步代码块

2017-02-27 16:08:59

什么是同步代码块使用synchronize关键字加上锁对象来定义一段代码，这就叫同步代码块。什么时候使用同步代码块当多线程并发，有多段代码同时执行，如果希望一段代码在执行过程中多CPU不要切换到其他线程工作，这时就...

什么是同步代码块

使用synchronize关键字加上锁对象来定义一段代码，这就叫同步代码块。



什么时候使用同步代码块

当多线程并发，有多段代码同时执行，如果希望一段代码在执行过程中多CPU不要切换到其他线程工作，这时就需要用到同步代码块。



示例



public class Demo1_Synchronized {

    public static void main(String[] args) {
        Printer p = new Printer();
        new Thread(){
            public void run(){
                while(true){
                    p.print1();
                }
            }
        }.start();

        new Thread(){
            public void run(){
                while(true){
                    p.print2();
                }
            }
        }.start();
    }

}

class Printer{
    Demo d = new Demo();
    public void print1(){
        synchronized(Printer.class) {                 // 同步代码块，锁机制，锁对象可以是任意的,但两条线程的锁对象要相同，括号中也可以传d
            System.out.print("同");
            System.out.print("步");
            System.out.print("代");
            System.out.print("码");
            System.out.print("块");
            System.out.println();
        }
    }

    public void print2(){
        synchronized(Printer.class){                         // 锁对象不能用匿名对象，因为匿名对象不是同一个对象
            System.out.print("s");
            System.out.print("y");
            System.out.print("n");
            System.out.print("c");
            System.out.print("h");
            System.out.print("r");
            System.out.print("o");
            System.out.print("n");
            System.out.print("i");
            System.out.print("z");
            System.out.print("e");
            System.out.print("d");
            System.out.println();
        }
    }
}

class Demo{}



同步方法

在方法上加synchronize关键字，就是同步方法。 

非静态同步方法的锁对象是this 

静态方法的锁对象是该类的字节码对象

收起

展开全文

Java同步代码块

2019-06-05 14:36:23

什么是同步代码块： 同步代码块是共用同一把锁的代码块，使用同步代码块可以实现两块代码在执行过程中互斥。即执行代码块A的时候不执行代码块B，执行代码块B的时候不执行代码块A。实现方法：使用静态对象锁...

什么是同步代码块：

同步代码块是共用同一把锁的代码块，使用同步代码块可以实现两块代码在执行过程中互斥。

即执行代码块A的时候不执行代码块B，执行代码块B的时候不执行代码块A。

 

实现方法：

使用静态对象锁。

private static final Object SYNCHRONIZED_OBJECT = new Object();

 

举个栗子：

public class LockDemo{

    /**
     * 静态对象锁
     */
    private static final Object SYNCHRONIZED_OBJECT = new Object();

    public void method1() {
        synchronized (SYNCHRONIZED_OBJECT) {
            System.out.println("method1 start");
            for (int i=1;i<=4;i++) {
                System.out.println("method1:"+i);
                try {
                    Thread.sleep(1000);
                }
                catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            System.out.println("method1 end");
        }
    }


    public void method2() {
        synchronized (SYNCHRONIZED_OBJECT) {
            System.out.println("method2 start");
            for (int i=1;i<=4;i++) {
                System.out.println("method2:"+i);
                try {
                    Thread.sleep(1000);
                }
                catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            System.out.println("method2 end");
        }
    }

}

public class TestDemo {

    /**
     * 两个对象共用同一把静态对象锁，分别启用两个线程来执行这两个对象的不同方法，可见两个代码块互斥
     */
    @Test
    public void test1() {
        LockDemo lockDemo1 = new LockDemo();
        LockDemo lockDemo2 = new LockDemo();
        
        ThreadDemo demo1 = new ThreadDemo(lockDemo1,"method1");
        ThreadDemo demo2 = new ThreadDemo(lockDemo2,"method2");
        demo2.start();
        demo1.start();

        try {
            demo1.join();
            demo2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}


/**
 * 线程例子
 */
class ThreadDemo extends Thread{

    LockDemo lockDemo;
    String method;

    ThreadDemo(LockDemo lockDemo,String method) {
        this.lockDemo = lockDemo;
        this.method = method;
    }


    @Override
    public void run() {
        if (method.equals("method1")) {
            lockDemo.method1();
        } else {
            lockDemo.method2();
        }
    }
}



执行结果：

收起

展开全文

Java使用同步代码块

千次阅读 2019-05-26 20:25:19

为了解决线程安全问题，Java的多线程支持引入了同步监视器来解决这个问题，使用同步监视器的通用方法就是同步代码块。 同步代码块的语法格式如下： synchronized(obj) { //同步代码块 } } obj叫做同步监视...

为了解决线程安全问题，Java的多线程支持引入了同步监视器来解决这个问题，使用 同步监视器的通用方法就是同步代码块。

同步代码块的语法格式如下：

synchronized (obj) 

    {

        //同步代码块 }

}

obj叫做同步监视器（即锁对象），任何线程进入下面同步代码块之前必须先获得对obj 的锁；其他线程无法获得锁，也就执行同步代码块。这种做法符合：“加锁修改释放锁”的逻辑。锁对象可以是任意对象，但必须保证是同一对象任何时刻只能有一个线程可以获得对同步监视器的锁定，当同步代码块执行完成后该线程会释放对该同步监视器的锁定。

示例代码：

首先使用一个javaBean类模拟用户账户信息

package com.gx.threaddemo;

 

import java.io.Serializable;

 

publicclass Account implements Serializable {

    privatestaticfinallongserialVersionUID = 1L;

    // 银行账户

    private String number;

    // 账户余额

    privatedoublemoney;

    public Account(Stringnumber, double money) {

        this.number = number;

        this.money = money;

    }

    public String getNumber(){

        returnnumber;

    }

    publicvoid setNumber(Stringnumber) {

        this.number = number;

    }

    publicdouble getMoney() {

        returnmoney;

    }

    publicvoid setMoney(double money) {

        this.money = money;

    }

}

创建一个线程类模拟取钱过程

class TakeMoney extends Thread {

    // 谁取钱

    private String name;

    // 账户对象

    private Account account;

    // 取款金额

    privatedoubletakeMoney;

    public TakeMoney(Stringname, Account account, double takeMoney) {

        this.name = name;

        this.account = account;

        this.takeMoney = takeMoney;

    }

    @Override

    publicvoid run() {

        // 加锁

        synchronized (account) {

            if (takeMoney <= account.getMoney()) {

                System.out.println(this.name + "取钱成功，取出" + takeMoney + "元");

                // 线程暂停 10ms 模拟网络传输

                try {

                    sleep(10);

                }catch(InterruptedException e) {

                    // TODO Auto-generated catch block

                    e.printStackTrace();

                }

                // 修改余额

                double money = account.getMoney() - takeMoney;

                System.out.println("计算余额 = " + money);

                account.setMoney(money);

                System.out.println("账户：" + account.getNumber() + "余额为： "

                        +account.getMoney());

            }else {

                System.out.println(this.name + "取钱失败，原因：" + account.getNumber()

                        +"账户余额不足！");

            }

        }

        //  同步代码块执行结束，线程释放同步锁

    }

}

创建两个线程并运行，模拟AB两人同时取钱情况

package com.gx.threaddemo;

 

import java.util.Random;

publicclass TakeMoneyDemo {

    publicstaticvoid main(String[] args){

        Accountaccount = new Account("666666", 5000);

        //TakeMoney 使用了同步代码块，不存在安全问题

        TakeMoneytakeMoney1 = new TakeMoney("小明", account, 1000);

        TakeMoneytakeMoney2 = new TakeMoney("小红", account, 4500);

 

        // 通过随机数，随机先启动某个程序

        Randomrandom = new Random();

        int randmoInt =random.nextInt(100);

        if (randmoInt % 2 ==0) {

            takeMoney1.start();

            takeMoney2.start();

        }else {

            takeMoney2.start();

            takeMoney1.start();

        }

        // 等待子线程结束

        try {

            Thread.sleep(1000);

        }catch(InterruptedException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        System.out.println(account.getNumber()+ "账户最终余额：" + account.getMoney());

    }

}

代码执行结果如下，这样就不会出现超取的情况：

收起

展开全文

java synchronized对象锁与类锁的区别、同步代码块与同步方法的区别

万次阅读 多人点赞 2017-05-19 23:34:14

线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。 java内置锁是一个互斥锁，这就是意味着最多只有一个线程...

终于搞明白synchronized的作用了，献上一篇，如下：

java的内置锁：每个java对象都可以用做一个实现同步的锁，这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。

获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。


java内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞，知道线程B释放这个锁，

如果B线程不释放这个锁，那么A线程将永远等待下去。


java的对象锁和类锁：java的对象锁和类锁在锁的概念上基本上和内置锁是一致的，但是，两个锁实际是有很大的区别的，对象锁是用于对象实例方法，

或者一个对象实例上的，类锁是用于类的静态方法或者一个类的class对象上的。我们知道，类的对象实例可以有很多个，但是每个类只有一个class对象，

所以不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁。但是有一点必须注意的是，其实类锁只是一个概念上的东西，并不是真实存在的，

它只是用来帮助我们理解锁定实例方法和静态方法的区别的。

 

public class TestSynchronized 
{  
    public void test1() 
    {  
         synchronized(this) 
         {  
              int i = 5;  
              while( i-- > 0) 
              {  
                   System.out.println(Thread.currentThread().getName() + " : " + i);  
                   try 
                   {  
                        Thread.sleep(500);  
                   } 
                   catch (InterruptedException ie) 
                   {  
                   }  
              }  
         }  
    }  
    public synchronized void test2() 
    {  
         int i = 5;  
         while( i-- > 0) 
         {  
              System.out.println(Thread.currentThread().getName() + " : " + i);  
              try 
              {  
                   Thread.sleep(500);  
              } 
              catch (InterruptedException ie) 
              {  
              }  
         }  
    }  
    public static void main(String[] args) 
    {  
         final TestSynchronized myt2 = new TestSynchronized();  
         Thread test1 = new Thread(  new Runnable() {  public void run() {  myt2.test1();  }  }, "test1"  );  
         Thread test2 = new Thread(  new Runnable() {  public void run() { myt2.test2();   }  }, "test2"  );  
         test1.start();;  
         test2.start();  
//         TestRunnable tr=new TestRunnable();
//         Thread test3=new Thread(tr);
//         test3.start();
    } 
}
 
test2 : 4
test2 : 3
test2 : 2
test2 : 1
test2 : 0
test1 : 4
test1 : 3
test1 : 2
test1 : 1
test1 : 0

public class TestSynchronized 
{  
    public void test1() 
    {  
         synchronized(TestSynchronized.class) 
         {  
              int i = 5;  
              while( i-- > 0) 
              {  
                   System.out.println(Thread.currentThread().getName() + " : " + i);  
                   try 
                   {  
                        Thread.sleep(500);  
                   } 
                   catch (InterruptedException ie) 
                   {  
                   }  
              }  
         }  
    }  
    public static synchronized void test2() 
    {  
         int i = 5;  
         while( i-- > 0) 
         {  
              System.out.println(Thread.currentThread().getName() + " : " + i);  
              try 
              {  
                   Thread.sleep(500);  
              } 
              catch (InterruptedException ie) 
              {  
              }  
         }  
    }  
    public static void main(String[] args) 
    {  
         final TestSynchronized myt2 = new TestSynchronized();  
         Thread test1 = new Thread(  new Runnable() {  public void run() {  myt2.test1();  }  }, "test1"  );  
         Thread test2 = new Thread(  new Runnable() {  public void run() { TestSynchronized.test2();   }  }, "test2"  );  
         test1.start();  
         test2.start();  
//         TestRunnable tr=new TestRunnable();
//         Thread test3=new Thread(tr);
//         test3.start();
    } 
}
 

test1 : 4
test1 : 3
test1 : 2
test1 : 1
test1 : 0
test2 : 4
test2 : 3
test2 : 2
test2 : 1
test2 : 0

public class TestSynchronized 
{  
    public synchronized void test1() 
    {  
              int i = 5;  
              while( i-- > 0) 
              {  
                   System.out.println(Thread.currentThread().getName() + " : " + i);  
                   try 
                   {  
                        Thread.sleep(500);  
                   } 
                   catch (InterruptedException ie) 
                   {  
                   }  
              }  
    }  
    public static synchronized void test2() 
    {  
         int i = 5;  
         while( i-- > 0) 
         {  
              System.out.println(Thread.currentThread().getName() + " : " + i);  
              try 
              {  
                   Thread.sleep(500);  
              } 
              catch (InterruptedException ie) 
              {  
              }  
         }  
    }  
    public static void main(String[] args) 
    {  
         final TestSynchronized myt2 = new TestSynchronized();  
         Thread test1 = new Thread(  new Runnable() {  public void run() {  myt2.test1();  }  }, "test1"  );  
         Thread test2 = new Thread(  new Runnable() {  public void run() { TestSynchronized.test2();   }  }, "test2"  );  
         test1.start();  
         test2.start();  
//         TestRunnable tr=new TestRunnable();
//         Thread test3=new Thread(tr);
//         test3.start();
    } 
}
 

test1 : 4
test2 : 4
test1 : 3
test2 : 3
test2 : 2
test1 : 2
test2 : 1
test1 : 1
test1 : 0
test2 : 0

 


 

上面代码synchronized同时修饰静态方法和实例方法，但是运行结果是交替进行的，这证明了类锁和对象锁是两个不一样的锁，控制着不同的区域，它们是互不干扰的。同样，线程获得对象锁的同时，也可以获得该类锁，即同时获得两个锁，这是允许的。

 

这时如果直接用synchronized修饰调用了so.testsy();代码的方法，那么当某个线程进入了这个方法之后，这个对象其他同步方法都不能给其他线程访问了。假如这个方法需要执行的时间很长，那么其他线程会一直阻塞，影响到系统的性能。如果这时用synchronized来修饰代码块：synchronized（so）{so.testsy();}，那么这个方法加锁的对象是so这个对象，跟执行这行代码的对象没有关系，当一个线程执行这个方法时，这对其他同步方法时没有影响的，因为他们持有的锁都完全不一样。不过这里还有一种特例，就是上面演示的第一个例子，对象锁synchronized同时修饰方法和代码块，这时也可以体现到同步代码块的优越性，如果test1方法同步代码块后面有非常多没有同步的代码，而且有一个100000的循环，这导致test1方法会执行时间非常长，那么如果直接用synchronized修饰方法，那么在方法没执行完之前，其他线程是不可以访问test2方法的，但是如果用了同步代码块，那么当退出代码块时就已经释放了对象锁，当线程还在执行test1的那个100000的循环时，其他线程就已经可以访问test2方法了。这就让阻塞的机会或者线程更少。让系统的性能更优越。

 

public class Main {
	class Inner {
		private void m4t1() {
			int i = 5;
			while (i-- > 0) {
				System.out.println(Thread.currentThread().getName()
						+ " : Inner.m4t1()=" + i);
				try {
					Thread.sleep(500);
				} catch (InterruptedException ie) {
				}
			}
		}//m4t1

		private  synchronized void m4t2() {
			int i = 5;
			while (i-- > 0) {
				System.out.println(Thread.currentThread().getName()
						+ " : Inner.m4t2()=" + i);
				try {
					Thread.sleep(500);
				} catch (InterruptedException ie) {
				}
			}
		}//m4t2
	}//inner

	private void m4t1(Inner inner) {
		synchronized (inner) { // 使用对象锁
			inner.m4t1();
		}
	}

	private void m4t2(Inner inner) {
		inner.m4t2();
	}

	public static void main(String[] args) {
		final Main myt3 = new Main();
		final Inner inner = myt3.new Inner();
		Thread t1 = new Thread(new Runnable() {
			public void run() {
				myt3.m4t1(inner);
			}
		}, "t1");
		Thread t2 = new Thread(new Runnable() {
			public void run() {
				myt3.m4t2(inner);
			}
		}, "t2");
		t1.start();
		t2.start();
	}
}
//t1 : Inner.m4t1()=4
//t1 : Inner.m4t1()=3
//t1 : Inner.m4t1()=2
//t1 : Inner.m4t1()=1
//t1 : Inner.m4t1()=0
//t2 : Inner.m4t2()=4
//t2 : Inner.m4t2()=3
//t2 : Inner.m4t2()=2
//t2 : Inner.m4t2()=1
//t2 : Inner.m4t2()=0

public class SynObj{
    public synchronized void showA(){
        System.out.println("showA..");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public void showB(){
        synchronized (this) {
        	System.out.println(this.getClass().getSimpleName());
            System.out.println("showB..");
        }
    }
    
    public void showC(){
        String s="1";
        synchronized (s) {
            System.out.println("showC..");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        final SynObj sy=new SynObj();
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                sy.showA();
            }
        }).start();
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                sy.showB();
            }
        }).start();
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                sy.showC();
            }
        }).start();
    }
}

//showA..
//showC..
//SynObj
//showB..


这段代码的打印结果是，showA…..showC…..会很快打印出来，showB…..会隔一段时间才打印出来，那么showB为什么不能像showC那样很快被调用呢？

　　在启动线程1调用方法A后，接着会让线程1休眠3秒钟，这时会调用方法C，注意到方法C这里用synchronized进行加锁，这里锁的对象是s这个字符串对象。

但是方法B则不同，是用当前对象this进行加锁，注意到方法A直接在方法上加synchronized，这个加锁的对象是什么呢？显然，这两个方法用的是一把锁。

　　*由这样的结果，我们就知道这样同步方法是用什么加锁的了，由于线程1在休眠，这时锁还没释放，导致线程2只有在3秒之后才能调用方法B，

由此，可知两种加锁机制用的是同一个锁对象，即当前对象。 

　　另外，同步方法直接在方法上加synchronized实现加锁，同步代码块则在方法内部加锁，很明显，同步方法锁的范围比较大，

而同步代码块范围要小点，一般同步的范围越大，性能就越差，一般需要加锁进行同步的时候，肯定是范围越小越好，这样性能更好*。

 

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。

另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。 

二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。 

三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

对象锁和类锁可以同时获得，即两种方法可以同时运行，互不影响；

一种锁方法只能运行同时运行一个，同种其他的锁方法暂时阻塞，普通方法的运行不受限制

参考：

http://www.cnblogs.com/wl0000-03/p/5973039.html

http://www.cnblogs.com/xujingyang/p/6565606.html

http://blog.csdn.net/h_gao/article/details/52266950

http://blog.csdn.net/zhenwodefengcaii/article/details/54601098 

 

更多企业内的技术应用和使用技巧，请移步至我的公众号【程序员实用技能】

收起

展开全文

java

同步方法和同步代码块的区别
万次阅读 2017-10-12 18:25:11
转自：牛客网 1.同步方法使用synchronized修饰方法，在调用该方法前，需要获得内置锁（java每个...2.同步代码块使用synchronized(object){}进行修饰，在调用该代码块时，需要获得内置锁，否则就处于阻塞状态
收起
同步方法 java
同步代码块和同步函数的区别
千次阅读 2014-12-06 17:42:13
同步代码块可以绑定任意对象，而同步函数只能绑定该类对象this，static同步函数只能绑定字节码类名.class如果多个线程使用同一个锁的话，那么两者均可以使用，如果存在多个锁的话，只能使用同步代码块开发推荐使用...
收起
同步代码块什么时候释放锁
千次阅读 2016-05-29 17:13:30
同步代码块什么时候释放锁
收起
Android
同步代码块，同步代码方法，锁
2017-04-03 09:45:00
1、同步代码块 synchronized(锁对象){ 需要被锁的代码//线程只有拿到了锁对象，才能执行这里的代码！！！换言之，这里的代码如果执行了，说明该线程拿到了锁对象，其他线程不能拿到该锁对象 } 注意多个线程...
收起
多线程
同步代码块、同步方法、锁总结
千次阅读 2017-06-07 22:34:51
同步代码块 1.为了解决并发操作可能造成的异常，java的多线程支持引入了同步监视器来解决这个问题，使用同步监视器的通用方法就是同步代码块，其语法如下： synchronized（obj）{ //同步代码块 } 其中obj就是同步...
收起
多线程
同步方法和同步代码块区别是什么
2020-02-13 16:49:40
同步代码块可以选择以什么来加锁，比同步方法要更细颗粒度，我们可以选择只同步会发生同步问题的部分代码而不是整个方法；同步方法使用关键字 synchronized修饰方法，而同步代码块主要是修饰需要进行同步的代码，用...
收起
java 同步代码块锁和同步函数锁
千次阅读 2018-05-11 14:59:27
同步函数和同步代码块的区别：同步函数的锁是固定的this。 同步代码块的锁是任意的对象。建议使用同步代码块。 */ class Ticket implements Runnable { private int num = 100; boolean flag = true; public...
收起
java中的静态代码块、构造代码块、普通代码块和同步代码块总结
千次阅读 2015-07-28 10:15:26
* java中还有一种代码块是同步代码块，常用在多线程中， synchronized关键字， * 同步代码块格式是：synchronized(同步对象){} * 静态代码块先于构造代码块先于构造方法执行 * 静态代码块先于普通代码块先于构造...
收起
同步代码块和同步方法有什么区别？
2019-11-16 11:27:11
同步代码块则是在方法内部使用 synchronized 加锁对象相同的话，同步方法锁的范围大于等于同步方法块。一般加锁范围越大，性能越差同步方法如果是 static 方法，等同于同步方法块加锁在该 Class 对象上【Java...
收起
多线程 同步代码块 锁
2015-12-26 11:41:55
学同步代码块时不是太明白同步和加锁，希望给个详细的解释同步和加锁含义是什么怎样解释
收起
多线程
Synchronized修饰方法和同步代码块的区别
千次阅读 2020-04-12 18:16:09
Synchronized修饰方法和同步代码块的区别 Synchronized修饰方法的底层实现原理 Synchronized修饰同步代码块底层实现原理代码验证 synchronized用法我们知道可以修饰实例方法，也可以修饰静态方法，还可以使用同步...
收起
java
java同步方法和同步代码块
万次阅读 多人点赞 2017-01-18 14:45:38
一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
收起
C# lock关键字 同步代码块
千次阅读 2016-01-10 17:44:35
C# lock 同步代码块
收起
Java 同步函数和同步代码块锁
千次阅读 2016-01-28 04:16:08
* 同步函数和同步代码块的区别： * 同步函数的锁是固定的this。 * * 同步代码块的锁是任意的对象 * * 建议使用同步代码块 */ class Ticket_1 implements Runnable{ private int num = 400; Object...
收起
JAVA 同步方法和同步代码块的区别是什么？
万次阅读 2019-06-04 12:04:33
同步代码块可以选择以什么来加锁，比同步方法要更细颗粒度，我们可以选择只同步会发生同步问题的部分代码而不是整个方法；同步方法使用关键字 synchronized修饰方法，而同步代码块主要是修饰需要进行同步的代码，用...
收起
同步代码块和同步函数之间同步
千次阅读 2012-08-17 19:29:31
* 开始两个线程，一个线程调用同步代码块，另外一个调用同步函数，同步代码块和同步函数的代码一模一样，所以 * 同步代码块和同步函数两者之间也必须同步，即是不能存在一个线程调用同步代码块的同时另外一个线程...
收起
string thread class 多线程
JAVA线程同步方法和同步代码块
千次阅读 2018-08-08 16:35:58
JAVA 线程同步方法和同步代码块 线程安全和非线程安全脏读非线程安全：多个线程对同一个对象的中的实例变量进行并发访问，产生后果就是脏读，也就是获取的数据被更改。非线程安全问题存在与“实例变量”中，...
收起
java 线程
java 中同步方法和同步代码块的区别详解
千次阅读 2017-10-15 22:00:10
java 中同步方法和同步代码块的区别详解在Java语言中，每一个对象有一把锁。线程可以使用synchronized关键字来获取对象上的锁。synchronized关键字可应用在方法级别(粗粒度锁)或者是代码块级别(细粒度锁)。 ...
收起
同步方法
同步代码块、同步函数和静态同步函数
千次阅读 2018-04-01 10:14:21
同步代码块的锁可以是任意对象Object obj = new Object(); synchronized(obj) { if(num > 0) { try{Thread.sleep(10);} catch(InterruptedException e){}; System.out.println(Thread.currentThread()......
收起
java基础知识
java多线程中synchronized同步代码块执行问题
千次阅读 2018-05-17 14:22:05
在高洪岩老师的《java多线程编程核心技术》一书的用同步代码块解决同步方法的弊端一节中（p76页），有这样一句话：“当一个线程访问object的一个synchronized同步代码块时，另一个线程依然可以访问该object对象中的...
收起
Java中的同步代码块、同步方法、同步锁
万次阅读 多人点赞 2018-08-13 01:40:01
多线程容易出现问题的原因当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。...同步代码块 synchronized(obj) { //需要被同步的...
收起
多线程的线程安全与互斥解决方案——同步代码块/同步函数
千次阅读 2021-02-25 16:00:39
解决办法——同步代码块2.同步代码块（SellTicket线程）3.解决办法——同步函数2.同步函数（SellTicket线程）总结一、线程安全与互斥（案例说明） 1.经典案例 1、有100张电影票 2、设置三个窗口同时卖电影票 3、...
收起
多线程 java 编程语言
同一个类中多个持有不同锁的同步代码块会不会阻塞--关于同步代码块的一个疑问验证--
千次阅读 2018-06-07 10:48:52
供测试的共享对象的类：public class Demo { Student a=new Student(1,&... //新建两个对象供同步代码块加锁 Student b=new Student(2,"B"); public void changeA(){ synchronized (a){ //加锁a a....
收起
锁，同步代码块，同步方法区别
千次阅读 2016-02-22 16:32:27
锁，同步代码块，同步方法 1、同步代码块 synchronized(锁对象){ 需要被锁的代码//线程只有拿到了锁对象，才能执行这里的代码！！！换言之，这里的代码如果执行了，说明该线程拿到了锁对象，其他线程不能拿到...
收起
java多线程——同步方法和同步代码块
千次阅读 2016-01-30 14:20:47
java中每个对象都有同步锁，同步方法是指进入该方法时需要获取this对象的同步锁，而同步代码块则是可以指定需要获取哪个对象的同步锁，以下代码实际上一个效果： synchronized void t(){} void t(){ synchronized...
收起