1.synchronized
synchronized用于多线程访问，并且被修饰的部分不能同时被执行，是代码同步的一种方式。
①使用synchronized修饰方法
当多个线程同时访问被synchronized修饰的方法时，有且仅有一个线程可以被访问，当一个线程在访问时，其它线程只能等待。当一个线程访问完毕后，下一个线程才可以访问。
原理：当方法被synchronized修饰后，如果想要执行该方法就必须获得相应的锁。每个类有且仅有一个锁(针对静态方法)，每个类的实例也是有且仅有一个锁。当多个线程在同时访问同一个方法时，执行该方法就必须获得相应的锁，同时锁只有一个，所以只能有一个线程可以获得锁，其它的线程必须等待该线程释放锁后才能获取到该锁。
进阶说明：由于每个类只有一个锁，所以当一个类中有多个方法被synchronized修饰时，在同一时间内只能有一个方法可以获得锁，所以只有一个被synchronized修饰的方法可以执行。
举例说明：
public void showDo(String msg){
for(int i=0;i<1000000;i++){
if (i%100000==0){
System.out.println("打印结果" + msg + i/100000);
}
}
}
//使用
new Thread(){
@Override
public void run() {
super.run();
showDo("线程一");
}
}.start();
new Thread(){
@Override
public void run() {
super.run();
showDo("线程二");
}
}.start();
未加synchronized修饰方法，可以看到执行顺序是打乱的，无序的。
加了synchronized后：
public synchronized void showDo(String msg){
for(int i=0;i<1000000;i++){
if (i%100000==0){
System.out.println("打印结果" + msg + i/100000);
}
}
}
这也就是同步方法，这时synchronized锁定的是哪个对象呢？他锁定的是调用这个同步方法对象。也就是说，当一个对象P1在不同的线程中执行这个同步方法时，他们之间会形成互斥，达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却能够任意调用这个被加了synchronized关键字的方法。
上边的示例代码等同于如下代码：
public void method() {
synchronized (this) {
//…..
}
}
this指的是什么呢？他指的就是调用这个方法的对象，如P1。可见同步方法实质是将synchronized作用于object reference。――那个拿到了P1对象锁的线程，才能够调用P1的同步方法，而对P2而言，P1这个锁和他毫不相干，程序也可能在这种情形下摆脱同步机制的控制，造成数据混乱。
②使用synchronized修饰代码块
public void method(SomeObject so) {
synchronized(so) {
//…..
}
}
这时，锁就是so这个对象，谁拿到这个锁谁就能够运行他所控制的那段代码。当有一个明确的对象作为锁时，就能够这样写，但当没有明确的对象作为锁，只是想让一段代码同步时，能够创建一个特别的instance变量（得是个对象）来充当锁：
class Foo implements Runnable {
private byte[] lock = new byte[0]; // 特别的instance变量
Public void method() {
synchronized(lock) { //… }
}
//…..
}
注：零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。
举例说明：
private static String s1 = "";
private static String s2 = "aa";
public void showDo(String msg) {
synchronized (s1){
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
System.out.println("打印结果" + msg + i / 2);
}
}
}
}
public void showDo1(String msg) {
synchronized (s2){
for (int i = 0; i < 10; i++) {
if (i % 12 == 0) {
System.out.println("打印" + msg + i / 2);
}
}
}
}
//调用
new Thread() {
@Override
public void run() {
super.run();
showDo1("线程一");
}
}.start();
new Thread() {
@Override
public void run() {
super.run();
showDo("线程二");
showDo1("线程二");
}
}.start();
由上可得，多个同步锁，只有竞争同一个同步锁才会需要等待，不是竞争同一个锁的代码块互不影响。
③
2.
synchronized不能修饰构造函数
定义接口方法时不能使用synchronized
synchronized(this)锁的是当前对象，当前有几个对象，this就有多少份
synchronized(XX.class)这个与当前对象无关，只要锁是XX.class的都会被同步
如果同一个类中有多个方法使用了同步锁synchronized(this)或者多个方法被synchronized修饰，则多个线程访问该类中同步方法时，每次只能访问一个，其它的被阻塞。如:
public synchronized void A(){
......
}
public synchronized void B(){
......
}
有两个线程分别访问同一个对象T的A方法和B方法，则同时只能有一个方法被其中一个线程访问，另一个线程处于阻塞状态，因为方法A和B持有同一个对象锁，synchronized(this)也是类似的情况。
同一个类中有多个方法使用了同步锁synchronized修饰，且这些类是静态的，因为静态方法是属于类的，而不是属于某个对象的，所以它与synchronized(XX.class)类似。
public synchronized static void method() {
// todo
}
每个对象只有一个锁(lock)与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。
实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
更有一些技巧能够让我们对共享资源的同步访问更加安全：
①定义private 的instance变量+他的 get方法，而不要定义public/protected的instance变量。假如将变量定义为public，对象在外界能够绕过同步方法的控制而直接取得他，并改变他。这也是JavaBean的标准实现方式之一。
②假如instance变量是个对象，如数组或ArrayList，那上述方法仍然不安全，因为当外界对象通过get方法拿到这个instance对象的引用后，又将其指向另一个对象，那么这个private变量也就变了，岂不是很危险。 这个时候就需要将get方法也加上synchronized同步，并且，只返回这个private对象的clone()――这样，调用端得到的就是对象副本的引用了。
