方法一：动态同步锁

class Demo_thread implements Runnable{
    public static int sum = 0;
    public synchronized void add(){//同步锁，为动态方法
        for(int i=0;i<5000;i++){
            sum = sum + 1;
        }
    }
    public void run(){
        add();
    }
}

动态同步锁适用于Runnable类中不适用与Thread类，因为其锁的对象为当前实例对象，一个Thread类只能跑一条线程，每条线程是不同的对象，所以同步锁将不起作用。

方法二：静态同步锁

class Demo_thread2 extends Thread{
    public static int sum = 0;
    public static synchronized void add(){//为静态方法
        for(int i=0;i<5000;i++){
            sum = sum + 1;
        }
    }
    public void run(){
        add();
    }
}

静态同步锁可以用于Thread类，因为静态方法在内存中只有一个实例，不会随着new新的对象而再创建实例。

方法三：代码块同步锁

class Demo_thread implements Runnable{
    public static int sum = 0;
    public void add(){
        for(int i=0;i<5000;i++){
            synchronized(this){//使用代码段同步锁，可以选择同步锁定
                sum = sum + 1; //一段代码,而不必要锁定整个方法
            }
        }
    }
    public void run(){
        add();
    }
}

代码块同步锁同样分为动态和静态，区分跟方法同步锁一样，定义动静态代码块同步锁的方法的区别是synchronized(）跟的参数是动态还是静态，注意其接收的参数应该是一个实例对象，上面的方法中的this为传递本身，属于动态方法。下面为定义一段动态代码块同步锁的方法:

class Object{
//定义一个空类来给synchronized传参
}
class Demo_thread2 extends Thread{
    public static int sum = 0;
    public static Object lock = new Object();//实例化一个静态对象
    public void add(){
        for(int i=0;i<5000;i++){
             synchronized(lock){
                sum = sum + 1; 
            }
        }
    }
    public void run(){
        add();
    }
}

方法四：使用lock方法

import java.util.concurrent.locks.ReentrantLock;
class Demo_thread3 implements Runnable{
    public static int sum = 0;
    private final ReentrantLock lock=new ReentrantLock();//创建ReentrantLock k对象
    public void add(){
        lock.lock();//获取锁 如果该锁被另一个线程保持，则出于线程调度的目的，
        for(int i=0;i<5000;i++){//禁用当前线程，并且在获得锁之前，该线程将一直处于休眠状态
            sum = sum + 1;
        }
        lock.unlock();
    }
    public void run(){
        add();
    }
}

因为每次调用线程的时候都会创建一个新的lock对象，所以同理当在Thread类中使用lock时把ReentrantLock的修饰语变成static 静态就行了。