同步方法解决线程安全问题

synchronize关键字使用方式：

1）指定加锁对象

synchronized (obj){//obj为给定的对象实例，前面代码可能直接定义好
              ...
}

2）直接作用于实例方法：相当于对当前实例加锁，进入同步代码块前要获得当前实例的锁。

public synchronized void method(){
    
}

 使用lock方式：

class MyThread implements Runnable{
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
         //2.调用锁定方法lock()
         lock.lock();
         //3.调用解锁方法：unlock()
         lock.unlock();
    }
}

 synchronize在执行完相应的同步代码之后会自动释放同步监视器，而lock无论上锁还是解锁都需要手动实现。

开发中优先使用lock方式实现同步。

两种创建多线程的方式如何使用synchronize关键字：

1）通过继承Thread方式创建多线程：

class MyThread extends Thread{
     @Override
    public void run() {
        synchronized(obj){//第一种方式指定加锁对象，对部分代码块加锁
            ...
        }
    }
}

class MyThread extends Thread{
    public static synchronized void method(){//第二种方式，不在run()方法中对部分代码加锁，而是提取出来作为方法，对方法加锁
                                    //不加static,则同步监视器为调用方法的实例对象m1、m2，错误
                                    //加上static，则同步监视器为当前类MyThread,唯一，正确！
        ...
    }

     @Override
    public void run() {
        ...
        method();//调用上面加锁的方法
        ...
    }
}
main{
    MyThread m1 = new MyThread();
    MyThread m2 = new MyThread();
    m1.start();
    m2.start();
}

2)通过实现Runnable接口创建多线程

class MyThread implements Runnable{
     @Override
    public void run() {
        ...
        synchronized(this){//第一种方式：this这里是Mythread类的对象m,唯一，正确！
            ...
        }
        ...
    }
}

main(){
    MyThread m = new MyThread();
    Thread t1 = new Thread(m);
    Thread t2 = new Thread(m);
    t1.start();t2.start();
}

class MyThread implements Runnable{
    public synchronized void method(){//第二种方式：无需加static，同步监视器为m
        ...
    }
     @Override
    public void run() {
        ...
        method();
        ...
    }
}

main(){
    MyThread m = new MyThread();
    Thread t1 = new Thread(m);
    Thread t2 = new Thread(m);
    t1.start();t2.start();
}