线程（-）synchronized

线程安全的概念：

　　当多个线程访问某一个类（对象或方法）时，这个类始终都能表现出正确的行为，那么这个类（对象或者方法）就是线程安全的。

synchronized：可以在任意对象及方法上加锁，而加锁的这段代码称为“互斥区”或“临界区”

　　线程不安全的时候：

package com.java.day01;

public class MyThread extends Thread{
    
    private int count=5;
    
    public void run(){
        count--;
        System.out.println(this.currentThread().getName()+"  "+"count="+count);
    }
    
    
    public static void main(String[] args) {
        MyThread myThread  = new MyThread();
        
        Thread t1 = new Thread(myThread,"t1");
        Thread t2 = new Thread(myThread,"t2");
        Thread t3 = new Thread(myThread,"t3");
        Thread t4 = new Thread(myThread,"t4");
        Thread t5 = new Thread(myThread,"t5");
        
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        
    }
    
    
}

　　运行结果：

t2  count=3
t1  count=3
t3  count=2
t4  count=0
t5  count=0

　　线程安全：

package com.java.day01;

public class MyThread extends Thread{
    
    private int count=5;
    
    //synchronized加锁
    public synchronized void run(){
        
        count--;
        System.out.println(this.currentThread().getName()+"  "+"count="+count);
    }
    
    
    public static void main(String[] args) {
        MyThread myThread  = new MyThread();
        
        Thread t1 = new Thread(myThread,"t1");
        Thread t2 = new Thread(myThread,"t2");
        Thread t3 = new Thread(myThread,"t3");
        Thread t4 = new Thread(myThread,"t4");
        Thread t5 = new Thread(myThread,"t5");
        
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        
    }
    
    
}

　　运行结果：

t1  count=4
t4  count=3
t3  count=2
t2  count=1
t5  count=0

　　总结：

　　　　当多个线程访问myThread的run方法时，以排队的方式进行处理（排队顺序按照cpu分配的先后顺序而定），一个线程想要执行synchronized修饰的方法里的代码，首先是尝试获得锁，如果拿到锁，执行synchronized代码的具体内容：拿不到锁，这个线程会不断的尝试获得这把锁，知道拿到为止，而且是多个线程同时去竞争这把锁（也就是会有锁竞争的问题）。

多个线程多个锁：多个线程都可以拿到自己指定的锁，分别获得锁之后，执行synchronized方法体的具体内容

　　代码一：

package com.java.day01;

public class MyThread02 {
    public static int num=0;
    
    public  synchronized void setNum(String tag){
        if(tag.equals("a")){
            
            num=100;
            System.out.println("set num over!");
            
        }else if(tag.equals("b")){
            
            num=200;
            System.out.println("set num over!");
            
        }
        
        System.out.println("tag="+tag+"  num="+num);
    }
    
    
    public static void main(String[] args) {
        final MyThread02 m1 =  new MyThread02();
        final MyThread02 m2 =  new MyThread02();
        
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                m1.setNum("a");
            }
        });
        
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                m2.setNum("b");
            }
        });
        
        t1.start();
        t2.start();
        
        
    }
    
    
}

　　执行结果：

set num over!
set num over!
tag=a  num=200
tag=b  num=200

执行结果与预期不同，并没有实现线程安全

结果分析：num为共享变量，但是两个对象获得的是两个各自对象的锁，所以两个方法可以说是同时进行，并没有被锁住

　　代码二 给方法加入static：

package com.java.day01;

public class MyThread02 {
    public static int num=0;
    
    public static  synchronized void setNum(String tag){
        if(tag.equals("a")){
            
            num=100;
            System.out.println("tag a  set num over!");
            
        }else if(tag.equals("b")){
            
            num=200;
            System.out.println("tag b set num over!");
            
        }
        
        System.out.println("tag="+tag+"  num="+num);
    }
    
    
    public static void main(String[] args) {
        final MyThread02 m1 =  new MyThread02();
        final MyThread02 m2 =  new MyThread02();
        
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                m1.setNum("a");
            }
        });
        
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                m2.setNum("b");
            }
        });
        
        t1.start();
        t2.start();
        
        
    }
    
    
}

　　运行结果：

tag a  set num over!
tag=a  num=100
tag b set num over!
tag=b  num=200

总结：

　　关键字synchronized取得的锁都是对象锁，而不是把一段代码（方法）当作锁，所以实例中的那哪个线程先执行synchronized关键字的方法，哪个线程就持有该方法所属对象的锁（Lock），两个对象，线程获得的就是两个不同的锁，他们互不影响。

　　有一种情况则是相同的锁，即在静态方法上加synchronized关键字，表锁定class类，类级别的锁（独占class类）

对象锁的同步和异步

同步：synchronized

　　同步的概念就是共享，我们要牢牢记住“共享”这两个字，如果不是共享资源，就没有必要进行同步。

异步：asynchronized

　　异步的概念就是独立，相互之间不受任何制约。就好像我们学习http的时候，在页面发起的ajax请求，我们还可以继续浏览或操作页面内容，二者之间没有任何关系。

同步的目的就是为了线程安全，其实对于线程来说，需要满足两个特性：

　　　　原子性（同步）

　　　　可见性

代码一：

package com.java.day01;

public class MyThread03 {
    public synchronized void method1(){
        System.out.println(Thread.currentThread().getName());
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public void method2(){
        System.out.println(Thread.currentThread().getName());
    }
    
    public static void main(String[] args) {
        final MyThread03 myThread = new MyThread03();
        
        Thread t1= new Thread(new Runnable() {
            public void run() {
                myThread.method1();
            }
        },"t1");
        
        Thread t2  = new Thread(new Runnable() {
            public void run() {
                myThread.method2();
            }
        },"t2");
        
        t1.start();
        t2.start();
        
    }
    
}

运行结果：

　　

可以看出，在method1方法没有执行完的之后，method2方法已经执行完

代码2，给method2方法加上关键字synchronized：

package com.java.day01;

public class MyThread03 {
    public synchronized void method1(){
        System.out.println(Thread.currentThread().getName());
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public synchronized void method2(){
        System.out.println(Thread.currentThread().getName());
    }
    
    public static void main(String[] args) {
        final MyThread03 myThread = new MyThread03();
        
        Thread t1= new Thread(new Runnable() {
            public void run() {
                myThread.method1();
            }
        },"t1");
        
        Thread t2  = new Thread(new Runnable() {
            public void run() {
                myThread.method2();
            }
        },"t2");
        
        t1.start();
        t2.start();
        
    }
    
}

运行结果：

图1可以看出正在运行method1，method2并没有被运行，图2可以看出method1运行完之后method2也开始运行且运行完。

上述代码1的method1方法是同步的，method2方法是异步的

代码2的method1和method2方法都是同步的

 A线程先持有object对象的Lock锁，B线程如果在这个时候调用对象中的同步（synchronized）方法则需等待，也就是同步

A线程先持有object对象的Lock锁，B线程可以以异步的方式调用对象中的非synchronized修饰的方法

 脏读：

　　对于对象的同步和异步的方法，我们在设计自己的程序的时候，一定要考虑问题的整体，不然就会出现数据不一致的错误，很经典的错误就是脏读（dirty read）

代码1：

package com.java.day01;

public class DirtyRead {
    private String name="source";
    private int age=0;
    
    public synchronized void setValue(String name,int age){
        this.name=name;
        
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        this.age=age;
        
        System.out.println("setValue最终的结果："+"name:"+name+"  "+"age:"+age);
    }
    
    public void getValue(){

        System.out.println("getValue方法最终得到的结果：   "+"name:"+name+"  "+"age:"+age);
    }
    
    
    public static void main(String[] args) {
        final DirtyRead dr = new DirtyRead();
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                dr.setValue("test1", 25);
            }
        });
        
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                dr.getValue();
            }
        });
        
        
        t1.start();
        t2.start();
        
    }
}

运行结果：

getValue方法最终得到的结果：   name:test1  age:0
setValue最终的结果：name:test1  age:25

得到错误的数据

代码2，给getValue方法加锁：

package com.java.day01;

public class DirtyRead {
    private String name="source";
    private int age=0;
    
    public synchronized void setValue(String name,int age){
        this.name=name;
        
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        this.age=age;
        
        System.out.println("setValue最终的结果："+"name:"+name+"  "+"age:"+age);
    }
    
    public synchronized void getValue(){

        System.out.println("getValue方法最终得到的结果：   "+"name:"+name+"  "+"age:"+age);
    }
    
    
    public static void main(String[] args) {
        final DirtyRead dr = new DirtyRead();
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                dr.setValue("test1", 25);
            }
        });
        
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                dr.getValue();
            }
        });
        
        
        t1.start();
        t2.start();
        
    }
}

运行结果：

setValue最终的结果：name:test1  age:25
getValue方法最终得到的结果：   name:test1  age:25

上述结果是setValue方法执行完之后，在执行getValue方法。

总结：

　　在我们对一个对象的方法加锁的时候，需要考虑业务的整体性，即为setValue/getValue方法同时加锁synchronized同步关键字，保证业务（service）的原子性，不然会出现业务错误（也从侧面保证业务的一致性）（如果在赋值的时候进行取值，则可能取到错误的数据）

（ACID  A：原子性  C:一致性  I:隔离性  D:永久性）

synchronized其他概念

synchronized锁重入：

　　关键字synchronized拥有锁重入的功能，也就是在使用synchronized时，当一个此线程得到了一个对象的锁之后，再次请求此对象时是可以再次得到该对象的锁。

 代码1：

　　

package com.java.day01;

/**
 * 
 * @author syousetu
 *锁的重入
 *
 */
public class SyncDubb01 {
    public synchronized void method01() {
        System.out.println("method01...");
        this.method02();
    }

    public synchronized void method02() {
        System.out.println("method02...");
        this.method03();
    }

    public synchronized void method03() {
        System.out.println("method03...");
    }
    
    public static void main(String[] args) {
        final SyncDubb01 s  = new SyncDubb01();
        
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                s.method01();
            }
        });
        
        t1.start();
        
    }
    
}

运行结果：

method01...
method02...
method03...

代码2：有继承关系的synchronized的应用

package com.java.day01;

/**
 * 
 * @author syousetu
 *
 *有继承关系的时候的synchronized的应用
 */
public class SyncDubb02 {

    static class Main {
        public int i = 10;

        public synchronized void operationSup() {
            try {

                i--;
                System.out.println("Main print i=" + i);

                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    static class Sub extends Main {
        public synchronized void operationSub() {
            while (i > 0) {

                try {
                    i--;
                    System.out.println("Sub print i=" + i);
                    Thread.sleep(1000);
                    //调用父类的方法
                    this.operationSup();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                
            }

        }

    }
    
    
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                Sub sub = new Sub();
                sub.operationSub();
            }
        });
        
        t1.start();
        
    }
    
    
    

}

运行结果：

Sub print i=9
Main print i=8
Sub print i=7
Main print i=6
Sub print i=5
Main print i=4
Sub print i=3
Main print i=2
Sub print i=1
Main print i=0

synchronized 出现异常，锁自动释放：

说明：对于web应用程序，异常释放锁的情况，如果不及时处理，很可能对你的应用程序逻辑业务产生严重的错误，比如，你现在在执行一个队列任务，很多对象都去等待第一个对象正确执行完毕再去释放锁，但是第一个对象由于异常的出现，导致业务逻辑没有正常执行完毕，就释放了锁，那么可想而知后续的对象执行的都是错误的逻辑。所以这一点一定要引起注意，在编写代码的时候一定要考虑周全。

package com.java.day01;

public class SyncException {
    private int i=0;
    
    public synchronized void opteration(){
        while(true){
            
            try {
                i++;
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName()+"  i:"+i);
            
                if(i==10){
                    Integer.parseInt("a");
                }
            } catch ( Exception e) {//interruptedException
                //捕获到异常输出，然后继续往下执行
                //出现异常后处理的方法：
                //1.将出现异常的数据记录在日志（出现异常的数据和后续的操作没有关联关系）或者continue
                //2.抛出运行异常或者打断异常
                System.out.println("出现异常 ：i="+i);
                e.printStackTrace();
//                throw new RuntimeException();
                continue;//跳过这次继续
            }
            
        }
    }
    
    public static void main(String[] args) {
        final SyncException s = new SyncException();
        Thread t1=  new Thread(new Runnable() {
            public void run() {
                s.opteration();
                
            }
        },"t1");
        
        t1.start();
        
        
    }
    
    
    
    
}

运行结果：

t1  i:1
t1  i:2
t1  i:3
t1  i:4
t1  i:5
t1  i:6
t1  i:7
t1  i:8
t1  i:9
t1  i:10
出现异常 ：i=10
java.lang.NumberFormatException: For input string: "a"
    at java.lang.NumberFormatException.forInputString(Unknown Source)
    at java.lang.Integer.parseInt(Unknown Source)
    at java.lang.Integer.parseInt(Unknown Source)
    at com.java.day01.SyncException.opteration(SyncException.java:15)
    at com.java.day01.SyncException$1.run(SyncException.java:35)
    at java.lang.Thread.run(Unknown Source)
t1  i:11
t1  i:12
t1  i:13

storm：做分布式计算

使用synchronized声明的方法在某些情况下是有弊端的，比如A线程调用同步的方法执行一个很长世间的任务，那么B线程就必须等待比较长的时间去执行，这样的情况下可以使用synchronized代码块去优化代码执行时间，也就是通常所说的减小锁的粒度。（demo1）

synchronized可以使用任意的object进行加锁（demo2）

另外特别注意一个问题，就是不要使用String的常量加锁，会出现死循环问题。（demo3）

代码1 采用字符串常量加锁：

package com.java.day01;

public class StringLock {

    public void method() {
        synchronized ("字符串常量") {

            while (true) {

                try {
                    System.out.println(Thread.currentThread().getName() + "线程开始");
                    Thread.sleep(200);
                    System.out.println(Thread.currentThread().getName() + "线程结束");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    public static void main(String[] args) {
        final StringLock sl = new StringLock();
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                sl.method();
            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {
            public void run() {
                sl.method();
            }
        }, "t2");

        t1.start();
        t2.start();

    }

}

运行结果：

t1线程开始
t1线程结束
t1线程开始
t1线程结束
t1线程开始

线程2获取不到锁

代码2 采用new String("字符串常量的方式加锁")：

package com.java.day01;

public class StringLock {

    public void method() {
        //new String("字符串常量");
        //"字符串常量"
        synchronized (new String("字符串常量")) {

            while (true) {

                try {
                    System.out.println(Thread.currentThread().getName() + "线程开始");
                    Thread.sleep(200);
                    System.out.println(Thread.currentThread().getName() + "线程结束");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    public static void main(String[] args) {
        final StringLock sl = new StringLock();
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                sl.method();
            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {
            public void run() {
                sl.method();
            }
        }, "t2");

        t1.start();
        t2.start();

    }

}

运行结果：

t2线程开始
t1线程开始
t2线程结束
t1线程结束
t1线程开始
t2线程开始

锁对象的改变问题，当使用一个对象进行加锁的时候，要注意对象本身发生改变的时候，那么持有的锁就不同。如果对象本身不发生改变，那么依然是同步的，即使是对象的属性发生了改变。（demo4）(用字符串常量进行加锁，在所里面修改字符串常量的值，预期锁本身应该发生了改变，但是，实验结果并没有得到验证；对于第二个实验，将对象的属性进行改变，锁仍然不改变)

死锁问题（demo5）