public class TestThreadcomtrue {
        public static void main(String [] srgs){
                Persion i=new Persion();
                new Thread(new Threadren(i)).start();
                new Thread(new Threadr(i)).start();
        }

}
class Threadren implements Runnable{
        Persion q=new Persion();
        Threadren(Persion q){this.q=q;}
        public void run(){
                q.get();
        }
}
class Threadr implements Runnable{
        Persion q=new Persion();
        Threadr(Persion q){this.q=q;}
        public void run(){
                q.put();
        }
}
class Persion{
        String name,sex;
        int i=1;
        public synchronized void get(){
                while(true){
                if(i%2==0){
                name="zs";
                try{Thread.sleep(1);}catch(Exception e){}
                sex="male";
                }
                else{
                name="lg";
                sex="famale";
                }
                i=(i+1)%2;
        }
}
        public synchronized void put(){
                while(true){
                System.out.println(name+" "+sex);
                }
        }
}

加上synchronized 也不出错就是没输出，去掉就没问题了。我看视频里加上就能实现同步，我加上就出问题了呢。

看看。。。。。。。。。。。。。。

多谢楼上的解说，我明白自己的错误了。

你get方法里的while(true)一直在运行使得第一个线程一直占着这个对象的锁，
这时你用另一个线程调用这个对象的另一个同步方法，当然获取不了这个对象的锁，
所以你加上synchronized之后不出错也没输出,如果去掉get()方法 里的while(true),如下

1. public synchronized void get(){
   
2.                         if(i%2==0){
   
3.                                         name="zs";
   
4.                                         try{Thread.sleep(1);}catch(Exception e){}
   
5.                                         sex="male";
   
6.                         }else{
   
7.                                 name="lg";
   
8.                                 sex="famale";
   
9.                         }
   
10.                         i=(i+1)%2;
    
11.         }

复制代码

这个时候就没问题了。

另外，当你去掉put()方法synchronized之后，那put()就是一个普通方法，这时第二个线程是可以调用这个对象的非同步方法的，所以就如你看到的结果一样了。

1、synchronized关键字的作用域有二种：
1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的 synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；
2）是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。

2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/}，它的作用域是当前对象；

不知道你理解没