首页 > 代码库 > 多线程编程-- part 3 多线程同步->synchronized关键字
多线程编程-- part 3 多线程同步->synchronized关键字
多线程同时访问一个资源，可以会产生不可预料的结果，所以为这个资源加锁,访问资源的第一个线程为其加锁后，其他线程便不能在使用那个资源，直到锁被解除。
举个例子：
存款1000元，能取出800的时候我就取800，当我同时用两个线程调用这个取钱操作时，有时可以取出1600元
static class HelloRunable implements Runnable{ private int money = 1000; //取出800元 int getMoney() { System.out.println("开始" + money); if(money > 800) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } money -= 800; System.out.println("我取了800元" + money); } System.out.println("结束" + money); return money; } @Override public void run() { money = getMoney(); } } public static void main(String[] args) { HelloRunable helloRunable = new HelloRunable(); Thread t = new Thread(helloRunable); Thread t1 = new Thread(helloRunable); t.start(); t1.start(); } 
synchronized：
所以我们引入了同步机制，在取钱方法前面加入了synchronized关键字，该方法称为同步方法，输出结果为
java中每个对象都有一个锁，或者叫做监视器(monitor),当一个线程访问某个对象的synchronized方法时，将该对象上锁，其他任何线程都无法再去访问该对象的synchronized方法，直到之前的那个线程执行完方法之后，才会将对象锁释放，其他线程才可以在用该对象的synchronized方法。 注：这是给对象上锁，如果是不同的对象则该对象之间没有限制关系。
如果一个对象有多个synchronized方法，某一时刻某个线程已经进入到了synchronized方法，那么在该方法没有执行完前，其他线程是无法访问该对象的任何synchronized方法的。
例如：
public static void main(String[] args) { Example example = new Example(); Thread t1 = new Thread1(example); Thread t2 = new Thread2(example); t1.start(); t2.start(); } static class Example { public synchronized void execute() { for (int i = 0; i < 20; ++i) { try { Thread.sleep((long) Math.random() * 1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Hello: " + i); } } public void execute2() { for (int i = 0; i < 20; ++i) { try { Thread.sleep((long) Math.random() * 1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("World: " + i); } } } static class Thread1 extends Thread { private Example example; public Thread1(Example example) { this.example = example; } @Override public void run() { example.execute(); } } static class Thread2 extends Thread { private Example example; public Thread2(Example example) { this.example = example; } @Override public void run() { example.execute2(); } } 
当加上synchronized后,当同步方法未执行完时另一个同步方法不会执行
静态的同步方法
当一个synchronized关键字修饰的方法同时被static修饰，非静态的同步方法会将对象上锁，但是静态方法不属于对象，而是属于类，他会将这个方法所在的类的Class对象上锁。
public static void main(String[] args) { Example example = new Example(); Thread t1 = new Thread1(example); example = new Example(); Thread t2 = new Thread2(example); t1.start(); t2.start(); } static class Example { public static synchronized void execute() { for (int i = 0; i < 20; ++i) { try { Thread.sleep((long) Math.random() * 1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Hello: " + i); } } public static synchronized void execute2() { for (int i = 0; i < 20; ++i) { try { Thread.sleep((long) Math.random() * 1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("World: " + i); } } } static class Thread1 extends Thread { private Example example; public Thread1(Example example) { this.example = example; } @Override public void run() { example.execute(); } } static class Thread2 extends Thread { private Example example; public Thread2(Example example) { this.example = example; } @Override public void run() { example.execute2(); } }
不加静态方法方法：
当某个synchronized方法是static的，那么当线程访问该方法时，他锁的并不是synchronized方法所在的对象，而是synchronized方法所在类的对应的class对象（java中，一个类无论有多少对象，这些对象会对应唯一的class对象，因此当线程分别访问一个类的两个对象的的两个static synchronized方法时，他们的执行顺序也是有顺序的，也就是说一个线程先去执行，执行完释放锁，另一个线程再去执行）
synchronized代码块
synchronized（object） {
}
表示的是在执行过程中会将object对象上锁（这个对象可以使任意类的对象，也可以使用this），可以自行规定上锁对象
public class test { public static void main(String[] args) { Example example = new Example(); Thread t1 = new Thread1(example); Thread t2 = new Thread2(example); t1.start(); t2.start(); }} class Example { private Object object = new Object(); public void execute() { System.out.println("我开始了"); synchronized (object) { for (int i = 0; i < 20; ++i) { try { Thread.sleep((long) Math.random() * 1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Hello: " + i); } } } public void execute2() { System.out.println("我也开始了"); synchronized (object) { for (int i = 0; i < 20; ++i) { try { Thread.sleep((long) Math.random() * 1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("World: " + i); } } } } class Thread1 extends Thread { private Example example; public Thread1(Example example) { this.example = example; } @Override public void run() { example.execute(); } } class Thread2 extends Thread { private Example example; public Thread2(Example example) { this.example = example; } @Override public void run() { example.execute2(); } }
可以看到除了synchronized代码块里的方法，其他是不会同步执行的。
synchronized方法是一种粗粒度的并发控制，某一时刻，只能有一个线程执行synchronized方法。
synchronized块则是细粒度的并发控制，只会将块中的代码同步，方法内的其他代码是可以被多个线程同时访问到的
多线程编程-- part 3 多线程同步->synchronized关键字