1. java 多线程 两个线程访问两个对象中不同的synchronized修饰的方法。（方法和对象都是同一个类的）
先上结论：两个线程访问不同对象中不同的synchronized方法不会受到synchronized的限制。
程序运行结果之所以这样，原因在于run()方法的实现导致的。
线程1中，先调用m.test1()，接着Thread.sleep(1000)
线程2中，先Thread.sleep(1000)，接着调用m.test2()
主程序中，线程1与2都有可能先开始，无论谁先开始，结果都是线程1中m.test1()先结束，线程2中m.test2()后结束。
因为轮到线程2时，先Thread.sleep(1000)，将资源让给线程1
改进方法，应该在打印时，让线程sleep
classTest{
synchronizedpublicvoidtest1(){
for(intp=0;p<5;p++){
try{
Thread.sleep(500);
}catch(InterruptedExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
System.out.println("s1.run.TestSynchronized_test1");
}
}
synchronizedpublicvoidtest2(){
for(intp=0;p<5;p++){
try{
Thread.sleep(500);
}catch(InterruptedExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
System.out.println("s2.run.TestSynchronized_test2");
}
}
}run()方法中直接调用即可
classTestSynchronized_1implementsRunnable{
privateTestm;
publicTestSynchronized_1(Testm){
this.m=m;
}
publicvoidrun(){
m.test1();
}
}
classTestSynchronized_2implementsRunnable{
privateTestm;
publicTestSynchronized_2(Testm){
this.m=m;
}
publicvoidrun(){
m.test2();
}
}输出结果如下：
s2.run.TestSynchronized_test 2
s2.run.TestSynchronized_test 2
s1.run.TestSynchronized_test 1
s1.run.TestSynchronized_test 1
s2.run.TestSynchronized_test 2
s1.run.TestSynchronized_test 1
s2.run.TestSynchronized_test 2
s1.run.TestSynchronized_test 1
s2.run.TestSynchronized_test 2
2. Java中线程同步的synchronized()(同步方法块)这个括号里的参数是啥
synchronized()、synchronized(this)、synchronized(类名.class)
synchronized加在非静态方法前和synchronized(this)都是锁住了这个类的对象，如果多线程访问，对象不同，就锁不住，对象固定是一个，就可锁住。
synchronized(类名.class)和加在静态方法前，是锁住了代码块，不管多线程访问的时候对象是不是同一个，能缩小代码段的范围就尽量缩小，能在代码段上加同步就不要再整个方法上加同步，缩小锁的粒度。
3. 初学Java多线程：使用Synchronized块同步方法
synchronized关键字有两种用法 第一种就是在《使用Synchronized关键字同步类方法》一文中所介绍的直接用在方法的定义中 另外一种就是synchronized块 我们不仅可以通过synchronized块来同步一个对象变量巧顷 也可以使用synchronized块来同步类中的静态孝宽陆方法和非静态方法
synchronized块的语法如下
public void method()
{
… …
synchronized(表达式)
{
… …
}
}
一 非静态类方法的同步
从《使用Synchronized关键字同步类方法》一文中我们知道使用synchronized关键字来定义方法就会锁定类中所有使用synchronzied关键字定义的静态方法或非静态方法 但这并不好理解 而如果使用synchronized块来达到同样的效果 就不难理解为什么会产生这种效果了 如果想使用synchronized块来锁定类中所有的同步非静态方法 需要使用this做为synchronized块的参数传入synchronized块国 代码如下
通过synchronized块同步非静态方法
public class SyncBlock
{
public void method ()
{
synchronized(this) // 相当于对method 方法使用synchronized关键字
{
… …
}
}
public void method ()
{
synchronized(this) // 相当于对method 方法使用synchronized关键字
{
… …
}
}
public synchronized void method ()
{
… …
}
}
在上面的代码中的method 和method 方法中使用了synchronized块 而第 行的method 方法仍然使用synchronized关键字来定义方法 在使用同一个SyncBlock类实例时 这三个方法只要有一个正在执行 其他两个方法就会因未获得同步锁而被阻塞 在使用synchronized块时要想达到和synchronized关键字同样的效果 必须将所有的代码都写在synchronized块中 否则 将无法使当前方法中的所有代码和其他的方法同步
除了使用this做为synchronized块的参数外 还可以使用SyncBlock this作为synchronized块的参数来达到同样的效果
在内类（InnerClass）的方法中使用synchronized块来时 this只表示内类 和外类(OuterClass)没有关系 但内类的非静态方法可以和外类的非静态方法同步 如在内类InnerClass中加一个method 方法 并使method 方法和SyncBlock的三个方法同步 代码如下
使内类的非静态方法和外类的非静态方法同步
public class SyncBlock
{
… …
class InnerClass
{
public void method ()
{
synchronized(SyncBlock this)
{
… …
}
}
}
… …
}
在上面SyncBlock类的新版本中 InnerClass类的method 方法和SyncBlock类的其他三个方法同步 因此 method method method 和method 四个方法在同一时间巧手只能有一个方法执行
Synchronized块不管是正常执行完 还是因为程序出错而异常退出synchronized块 当前的synchronized块所持有的同步锁都会自动释放 因此 在使用synchronized块时不必担心同步锁的释放问题
二 静态类方法的同步
由于在调用静态方法时 对象实例不一定被创建 因此 就不能使用this来同步静态方法 而必须使用Class对象来同步静态方法 代码如下
通过synchronized块同步静态方法
public class StaticSyncBlock
{
public static void method ()
{
synchronized(StaticSyncBlock class)
{
… …
}
}
public static synchronized void method ()
{
… …
}
}
在同步静态方法时可以使用类的静态字段class来得到Class对象 在上例中method 和method 方法同时只能有一个方法执行 除了使用class字段得到Class对象外 还可以使用实例的getClass方法来得到Class对象 上例中的代码可以修改如下
使用getClass方法得到Class对象
public class StaticSyncBlock
{
public static StaticSyncBlock instance;
public StaticSyncBlock()
{
instance = this;
}
public static void method ()
{
synchronized(instance getClass())
{
}
}
}
在上面代码中通过一个public的静态instance得到一个StaticSyncBlock类的实例 并通过这个实例的getClass方法得到了Class对象（一个类的所有实例通过getClass方法得到的都是同一个Class对象 因此 调用任何一个实例的getClass方法都可以） 我们还可以通过Class对象使不同类的静态方法同步 如Test类的静态方法method和StaticSyncBlock类的两个静态方法同步 代码如下
Test类的method方法和StaticSyncBlock类的method method 方法同步
public class Test
{
public static void method()
{
synchronized(StaticSyncBlock class)
{
}
}
}
lishixin/Article/program/Java/gj/201311/27374
4. Java多线程初学者指南（10）：使用Synchronized关键字同步类方法
要想解决 脏数据 的问题 最简单的方法就是使用synchronized关键字来使run方法同步 代码如下
publicsynchronizedvoidrun(){}
从上面的代码可以看出 只要在void和public之间加上synchronized关键字 就可以使run方法同步 也就是说 对于同一个Java类的对象实例 run方法同时只能被一个线程调用 并当前的run执行完后 才能被其他的线程调用 即使当前线程执行到了run方法中的yield方法 也只是暂停了一下 由于其他线程无法执行run方法 因此 最终还是会由当前的线程来继续执行 先看看下面的代码
sychronized关键字只和一个对象实例绑定
classTest{publicsynchronizedvoidmethod(){}纳察}{privateTesttest;publicvoidrun() { thod(); } publicSync(Testtest) { this test=test; } publicstaticvoidmain(String[]args)throwsException { Testtest =newTest(); Testtest =newTest(); Syncsync =newSync(test ); Syncsync =newSync(test ); newThread(sync ) start(); newThread(sync ) start(); } }
在Test类中的method方法是同步的 但上面的代码建立了两个Test类的实例 因此 test 和test 的method方法是分别执行的 要想让method同步 必须在建立仿茄升Sync类的实例时向它的构造方法中传入同一个Test类的实例 如下面的代码所示
Syncsync =newSync(test );
不仅可以使用synchronized来同步非静态方法 也可以使用synchronized来同步静态方法 如可以按如下方式来定义method方法
classTest{ (){}}
建立Test类的对象实例如下
Testtest=newTest();
对于静态方法来说 只要加上了synchronized关键字 这个方法就是同步的 无论是使用thod（） 还是使用thod（）来调用method方法 method都是同步的 并不存在非静态方法的多个实例的问题
在 种设计模式中的单件（Singleton）模式如果按传统的方法设计 也是线程不安全的 下面的代码是一个线程不安全的单件模式
packagetest;//线程安全的Singleton模式classSingleton{privatestaticSingletonsample;privateSingleton(){备老}(){if(sample==null){Thread yield();//为了放大Singleton模式的线程不安全性sample=newSingleton();}returnsample;}}{publicvoidrun(){Singletonsingleton=Singleton getInstance();System out println(singleton hashCode());}publicstaticvoidmain(String[]args){Threadthreads[]=newThread[ ];for(inti= ;i<threads length;i++)threads[i]=newMyThread();for(inti= ;i<threads length;i++)threads[i] start();}}
在上面的代码调用yield方法是为了使单件模式的线程不安全性表现出来 如果将这行去掉 上面的实现仍然是线程不安全的 只是出现的可能性小得多
程序的运行结果如下
上面的运行结果可能在不同的运行环境上有所有同 但一般这五行输出不会完全相同 从这个输出结果可以看出 通过getInstance方法得到的对象实例是五个 而不是我们期望的一个 这是因为当一个线程执行了Thread yield（）后 就将CPU资源交给了另外一个线程 由于在线程之间切换时并未执行到创建Singleton对象实例的语句 因此 这几个线程都通过了if判断 所以 就会产生了建立五个对象实例的情况（可能创建的是四个或三个对象实例 这取决于有多少个线程在创建Singleton对象之前通过了if判断 每次运行时可能结果会不一样）
要想使上面的单件模式变成线程安全的 只要为getInstance加上synchronized关键字即可 代码如下
(){}
当然 还有更简单的方法 就是在定义Singleton变量时就建立Singleton对象 代码如下
=newSingleton();
然后在getInstance方法中直接将sample返回即可 这种方式虽然简单 但不知在getInstance方法中创建Singleton对象灵活 读者可以根据具体的需求选择使用不同的方法来实现单件模式
在使用synchronized关键字时有以下四点需要注意
synchronized关键字不能继承
虽然可以使用synchronized来定义方法 但synchronized并不属于方法定义的一部分 因此 synchronized关键字不能被继承 如果在父类中的某个方法使用了synchronized关键字 而在子类中覆盖了这个方法 在子类中的这个方法默认情况下并不是同步的 而必须显式地在子类的这个方法中加上synchronized关键字才可以 当然 还可以在子类方法中调用父类中相应的方法 这样虽然子类中的方法不是同步的 但子类调用了父类的同步方法 因此 子类的方法也就相当于同步了 这两种方式的例子代码如下
在子类方法中加上synchronized关键字
classParent{ publicsynchronizedvoidmethod(){}}classChildextendsParent{ publicsynchronizedvoidmethod(){}}
在子类方法中调用父类的同步方法
classParent{ publicsynchronizedvoidmethod(){}}classChildextendsParent{publicvoidmethod(){thod();}}
在定义接口方法时不能使用synchronized关键字
构造方法不能使用synchronized关键字 但可以使用下节要讨论的synchronized块来进行同步
synchronized可以自由放置
在前面的例子中使用都是将synchronized关键字放在方法的返回类型前面 但这并不是synchronized可放置唯一位置 在非静态方法中 synchronized还可以放在方法定义的最前面 在静态方法中 synchronized可以放在static的前面 代码如下
publicsynchronizedvoidmethod();synchronizedpublicvoidmethod();();();();
但要注意 synchronized不能放在方法返回类型的后面 如下面的代码是错误的
publicvoidsynchronizedmethod();();
synchronized关键字只能用来同步方法 不能用来同步类变量 如下面的代码也是错误的
publicsynchronizedintn= ;publicstaticsynchronizedintn= ;
虽然使用synchronized关键字同步方法是最安全的同步方式 但大量使用synchronized关键字会造成不必要的资源消耗以及性能损失 虽然从表面上看synchronized锁定的是一个方法 但实际上synchronized锁定的是一个类 也就是说 如果在非静态方法method 和method 定义时都使用了synchronized 在method 未执行完之前 method 是不能执行的 静态方法和非静态方法的情况类似 但静态和非静态方法不会互相影响 看看如下的代码
packagetest;publicclassMyThread extendsThread{publicStringmethodName;publicstaticvoidmethod(Strings){System out println(s);while(true);}publicsynchronizedvoidmethod (){method( 非静态的method 方法 );}publicsynchronizedvoidmethod (){method( 非静态的method 方法 );} (){method( 静态的method 方法 );} (){method( 静态的method 方法 );}publicvoidrun(){try{getClass() getMethod(methodName) invoke(this);}catch(Exceptione){}}publicstaticvoidmain(String[]args)throwsException{MyThread myThread =newMyThread ();for(inti= ;i<= ;i++){thodName= method +String valueOf(i);newThread(myThread ) start();sleep( );}}}
运行结果如下
非静态的method 方法静态的method 方法
lishixin/Article/program/Java/gj/201311/27526