将synchronized方法与对象作为锁——T2105

package 对象及变量的并发访问2;

/**
 * 将synchronized方法与对象作为锁
 *
 *   在methodA()方法前加入关键字synchronized进行同步处理，程序排队执行，“共享”——只有共享资源的读写访问才需要同步
 * 化，如果不是共享资源，那么就没有同步的必要了。
 *
 *   结论：
 *   1）A线程现持有object对象的Lock锁，B线程可以以异步的方式调用object对象中的非synchronized类型方法。
 *   2）A线程先持有object对象的Lock锁，B线程如果再这时调用object对象中的synchronized类型的方法。则需要等待，也就是同步
 *   3）在方法声明处添加synchronized并不是锁方法，而是锁当前类的对象
 *   4）在java中只有“将对象作为锁”这种说法，并不是“锁方法”这种说法
 *   5）在java语言中。 ”锁“ 就是 ”对象“， ”对象“可以映射成”锁“， 那个线程拿到这个把锁，那个线程就可以执行这个对象中的synchronized同步方法
 *   6）如果在X对象中使用了synchronized关键字声明非静态方法，则X对象就是被当成锁。
 *
 */

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

/**
 * 测试
 */
class MyObjectT215{
  synchronized   public void methodA(){
        try {
            System.out.println("begin methA threadName="+Thread.currentThread().getName());
            Thread.sleep(1000);
            System.out.println("end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class MyObjet2T215{
    synchronized public void methodA2(){
        try {
            System.out.println("begin methodA2 threadName="+Thread.currentThread().getName());
            Thread.sleep(5000);
            System.out.println("end endTime="+System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
  synchronized   public void methodB2(){
        try {
            System.out.println("begin methodB2 threadName="+Thread.currentThread().getName()+"   begin Time="+System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
class MyThreadAT215 extends Thread{
    private  MyObjectT215 object;
    public MyThreadAT215(MyObjectT215 object){
        super();
        this.object=object;
    }

    @Override
    public void run() {
        super.run();
        object.methodA();
    }
}

class MyThreadA2T215 extends Thread{
    private MyObjet2T215 objet2T215;
    public MyThreadA2T215(MyObjet2T215 objet2T215){
        super();
        this.objet2T215=objet2T215;
    }

    @Override
    public void run() {
        super.run();
        objet2T215.methodA2();
    }
}
class MyThreadBT215 extends Thread{

    private MyObjectT215 objectT215;

    public MyThreadBT215(MyObjectT215 objectT215){
        super();
        this.objectT215=objectT215;
    }

    @Override
    public void run() {
        super.run();
        objectT215.methodA();
    }
}

class MyThreadB2T215 extends Thread{
    private MyObjet2T215 objet2T215;
    public MyThreadB2T215(MyObjet2T215 objet2T215){
        super();
        this.objet2T215=objet2T215;
    }

    @Override
    public void run() {
        super.run();
        objet2T215.methodB2();
    }
}

/**
 * 运行
 */
class RunT215{
    public  RunT215(){
        MyObjectT215 objectT215=new MyObjectT215();
        MyThreadAT215 at215=new MyThreadAT215(objectT215);
        at215.setName("A");
        MyThreadBT215 bt215=new MyThreadBT215(objectT215);
        bt215.setName("B");

        at215.start();
        bt215.start();
    }
}
class Run2T215{
    public Run2T215(){
        MyObjet2T215 objet2T215=new MyObjet2T215();
        MyThreadA2T215 a2T215=new MyThreadA2T215(objet2T215);
        a2T215.setName("A");
        MyThreadB2T215 b2T215=new MyThreadB2T215(objet2T215);
        b2T215.setName("B");
        a2T215.start();
        b2T215.start();
    }
}
public class T2105 {
    public static void main(String[] args) throws InterruptedException {
       // RunT215 runT215=new RunT215();

        Run2T215 run2T215=new Run2T215();
    }
}