线程同步synchronized与lock的区别

synchronized中代码块：任意对象。 synchronized(obj)

synchronized方法：锁定的为this对象，即new Class的本对象。

synchronized静态方法，锁定的为类对象。

T1为具体的方法，T2为线程对象，T3为运行类。

synchronized当发生异常时，锁会自动释放。且同步不具备继承性。

代码：

T1.java

package thread;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class T1 {
    
    public static int count=5;
     static Lock lock=new ReentrantLock(); //一定在此，此的话，可以让很多线程共用一把锁，从而实现同步功能。
    
    /*
    public synchronized static int reduce(){   // 此方法可行，可加锁
        
        System.out.println(Thread.currentThread().getName()+"，值为=  "+count);
        //System.out.println(count);
        count--;
        return count;
    }
    */
    
public  static int reduce(){
        //Lock lock=new ReentrantLock() // 如果在此处，无法实现并发，因为，此会生成很多锁，相互之间没有冲突，无线实现同步的功能。 应该加到最上面，让他们很多共用同一把锁
        lock.lock();
        try{
            System.out.println(Thread.currentThread().getName()+"，值为=  "+count);
            //System.out.println(count);
            count--;
            return count;
        }catch(Exception e){
            e.printStackTrace();
            return 0;
        }finally{
            // System.out.println(Thread.currentThread().getName()+"释放了锁");
             lock.unlock();
        }
        
    }
   

}
 

T2.java

package thread;

public class T2 extends Thread{

    @Override
    public void run(){
        T1.reduce();
        try {
            Thread.sleep(10);  //线程休息10毫秒
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}
 

T3.java

package thread;

public class T3 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
       
        T2 t2=new T2();
        for(int i=0;i<30;i++){
           Thread t=new Thread(t2);    //创建很多线程
           t.start(); //启动很多线程
        }
    }

}