java多线程程序现在很常见，和数据库操作系统一样，多个线程会共享一个堆内存，如果不加以控制，不进行线程之间的同步，会造成数据混乱等。
先看看下面这个程序：
public class TestSynchronized implements Runnable {Timer timer = new Timer();public static void main(String args[]) {TestSynchronized test = new TestSynchronized();Thread t1 = new Thread(test);Thread t2 = new Thread(test);t1.setName("t1");t2.setName("t2");t1.start();t2.start();}public void run() {timer.add(Thread.currentThread().getName());}}class Timer {private static int num = 0;public void add(String name) {// synchronized(this){ //没有同步，将导致num的数目不正常num++;try {Thread.sleep(1);} catch (Exception e) {}System.out.println(name + ", 你是第" + num + "个使用timer的线程");// }}}输出的结果：
t1, 你是第2个使用timer的线程t2, 你是第2个使用timer的线程
num两次都是2。这里很明显是两个线程在访问同一个Timer对象的num变量时交替进行，所以最后打印的时候都是2；
如何实现不同线程之间互斥访问这个num呢，使用synchronized同步代码块即可解决，用synchronized(this){}将需要同步代码块圈起来。
输出正常结果：
t2, 你是第1个使用timer的线程t1, 你是第2个使用timer的线程
synchronized的另一个用法是同步方法，就是在方法之前加上修饰符synchronized。那么不同线程在访问同一个对象的synchronized方法时就会互斥访问，从而达到同步
下面是一个经典的生产消费者模型代码：
public class TestSynchronized {public static void main(String[] args) {SyncStack ss = new SyncStack();Producer p = new Producer(ss);Consumer c = new Consumer(ss);Thread tp = new Thread(p);Thread tc = new Thread(c);tp.start();tc.start();}}class Bread {int id;Bread(int id) {this.id = id;}public String toString() {return "Bread: " + id;}}class SyncStack {int index = 0;Bread[] breads = new Bread[6];public synchronized void push(Bread b) {if (index == breads.length) {// 注意只能用while不能用if；因为wait会异常try {this.wait();// 访问当前对象的线程wait()} catch (InterruptedException e) {e.printStackTrace();}}this.notify();breads[index] = b;index++;System.out.println("生产了：" + b);}public synchronized Bread pop() {if (index == 0) {try {this.wait();// wait的时候锁已经不归该线程所有，但是sleep还有锁} catch (InterruptedException e) {e.printStackTrace();}}this.notify();// 叫醒一个正在该对象上wait的一个线程index–;System.out.println("消费了：" + breads[index]);return breads[index];}}class Producer implements Runnable {SyncStack ss = null;Producer(SyncStack ss) {this.ss = ss;}public void run() {for (int i = 0; i < 20; i++) {Bread b = new Bread(i);ss.push(b);// System.out.println("生产了："+b);try {Thread.sleep((int) Math.random() * 1000);} catch (InterruptedException e) {e.printStackTrace();}}}}class Consumer implements Runnable {SyncStack ss = null;Consumer(SyncStack ss) {this.ss = ss;}public void run() {for (int i = 0; i < 20; i++) {Bread b = null;b = ss.pop();// System.out.println("消费了："+breads[index]);//放到这里用if的话会出问题，先打出消费0，再打出生产0try {Thread.sleep((int) Math.random() * 1000);} catch (InterruptedException e) {e.printStackTrace();}}}}同步栈对象SyncStack的push和pop方法就是同步方法。生产者线程和消费者线程将会互斥访问pop和push方法。
下面说一下这种同步机制的实现。java为每个类对象分配一个独一无二的对象锁，每个线程要访问这个对象的成员就需要获得这个锁（当然这里是指需要同步的线程）。因为一个对象只有一个对象锁，所以一个线程在拿到锁之后，另一个访问相同对象的线程必须等待前者执行完成后释放掉对象锁，以此实现互斥。也就是说synchronized是针对对象的，不是针对类的。看看上面的图形。ObjectA和ObjectB是同一个类的不同实例，所以ThreadAn和ThreadBn没有关系。只有ThreadA1234同步，ThreadB1234亦是如此。并且对于非synchronized的方法和代码块，并没有影响，没有互斥
那有没有实现类级别上的同步呢？有的。在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成员变量的访问。 使用同步代码块是synchronized（classname.class）{}
最后几点总结来自：
1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；2）是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/}，它的作用域是当前对象；3、synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法；
对synchronized(this)的一些理解
如果你希望成功，以恒心为良友，以经验为参谋，以小心为兄弟，以希望为哨兵。
