java方法里的代码块 java代码块的用处

JAVA 中的 synchronized 代码块用法

Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

创新互联建站是一家专注于成都做网站、成都网站设计与策划设计,金安网站建设哪家好?创新互联建站做网站,专注于网站建设10余年,网设计领域的专业建站公司;建站业务涵盖:金安等地区。金安做网站价格咨询:18982081108

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

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

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

四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

五、以上规则对其它对象锁同样适用.

Java中，构造代码块和构造函数有什么区别？

构造代码块：是给所有的对象进行初始化，也就是说，所有的对象都会调用一个代码块，只要对象一建立，就会调用这个代码块。

构造函数：是给与之对应的对象进行初始化，它具有针对性。

请问java中一个方法只能执行一次静态代码块吗？一个类呢？

方法里没有静态代码块，类中的静态代码块没有个数限制，加载顺序是从上至下执行，也就是先执行最上边的静态代码块，依次往下

java 中同步方法和同步代码块的区别详解

在Java语言中，每一个对象有一把锁。线程可以使用synchronized关键字来获取对象上的锁。synchronized关键字可应用在方法级别(粗粒度锁)或者是代码块级别(细粒度锁)。

问题的由来：

看到这样一个面试题：

?

1

2

3

4

5

6

//下列两个方法有什么区别

public synchronized void method1(){}

public void method2(){

synchronized (obj){}

}

synchronized用于解决同步问题，当有多条线程同时访问共享数据时，如果进行同步，就会发生错误，Java提供的解决方案是：只要将操作共享数据的语句在某一时段让一个线程执行完，在执行过程中，其他线程不能进来执行可以。解决这个问题。这里在用synchronized时会有两种方式，一种是上面的同步方法，即用synchronized来修饰方法，另一种是提供的同步代码块。

这里总感觉怪怪的，这两种方法有什么区别呢，基础学得不好，于是就动手做了个简单的测试，代码如下：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

public class SynObj {

public synchronized void methodA() {

System.out.println("methodA.....");

try {

Thread.sleep(5000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

public void methodB() {

synchronized(this) {

System.out.pritntln("methodB.....");

}

}

public void methodC() {

String str = "sss";

synchronized (str) {

System.out.println( "methodC.....");

}

}

}

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

public class TestSyn {

public static void main(String[] args) {

final SynObj obj = new SynObj();

Thread t1 = new Thread(new Runnable() {

@Override

public void run() {

obj.methodA();

}

});

t1.start();

Thread t2 = new Thread(new Runnable() {

@Override

public void run() {

obj.methodB();

}

});

t2.start();

Thread t3 = new Thread(new Runnable() {

@Override

public void run() {

obj.methodC();

}

});

t3.start();

}

}

这段小代码片段打印结果如下：

?

1

2

3

4

methodA.....

methodC.....

//methodB会隔一段时间才会打印出来

methodB.....

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

在启动线程1调用方法A后，接着会让线程1休眠5秒钟，这时会调用方法C，注意到方法C这里用synchronized进行加锁，这里锁的对象是str这个字符串对象。但是方法B则不同，是用当前对象this进行加锁，注意到方法A直接在方法上加synchronized，这个加锁的对象是什么呢？显然，这两个方法用的是一把锁。

*由这样的结果，我们就知道这样同步方法是用什么加锁的了，由于线程1在休眠，这时锁还没释放，导致线程2只有在5秒之后才能调用方法B，由此，可知两种加锁机制用的是同一个锁对象，即当前对象。

另外，同步方法直接在方法上加synchronized实现加锁，同步代码块则在方法内部加锁，很明显，同步方法锁的范围比较大，而同步代码块范围要小点，一般同步的范围越大，性能就越差，一般需要加锁进行同步的时候，肯定是范围越小越好，这样性能更好。