多线程笔记：多线程基础 - 3

静态方法上的synchronized:
    如：
        synchronized public static void  printa(){ 。。。}
        
    静态方法上加synchronized和非静态方法上加这个关键字有本质的区别：
        加到静态方法上是给class类上锁，加到非静态方法上是给对象上锁
        
        
    如：
        public class Model{
            synchronized public static void  printa(){            //这里拿到的锁为class锁
                System.out.println("线程名称：" + Thread.currentThread().getName());
                try {
                    Thread.sleep(3000);
                    System.out.println("线程名称：" + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            synchronized public static void  printb(){            //这里拿到的锁为class锁
                System.out.println("线程名称：" + Thread.currentThread().getName());
                try {
                    Thread.sleep(2000);
                    System.out.println("线程名称：" + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            synchronized public void  printc(){                    //这里拿到的锁为对象锁
                System.out.println("线程名称：" + Thread.currentThread().getName());
                    //Thread.sleep(2000);
                System.out.println("线程名称：" + Thread.currentThread().getName());
            }
        }
    
        创建三个线程
            public class Thread1 extends Thread {

                private Model model;

                public Thread1(Model model) {
                    this.model = model;
                }

                @Override
                public void run() {
                    super.run();
                    Model.printa();
                }
            }
            
            public class Thread2 extends  Thread {
                private Model model;

                public Thread2(Model model) {
                    this.model = model;
                }

                @Override
                public void run() {
                    super.run();
                    model.printb();
                }
            }
            
            public class Thread3 extends  Thread {
                private Model model;

                public Thread3(Model model) {
                    this.model = model;
                }

                @Override
                public void run() {
                    super.run();
                    model.printc();
                }
            }
        运行一下代码：
            Model model = new Model();
            Thread1 thread1 = new Thread1(model);
            thread1.setName("a");
            thread1.start();

            Thread2 thread2 = new Thread2(model);
            thread2.setName("b");
            thread2.start();

            Thread3 thread3 = new Thread3(model);
            thread3.setName("c");
            thread3.start();
            
            运行结果：
                线程名称：a
                线程名称：c
                线程名称：c
                线程名称：a
                线程名称：b
                线程名称：b
            
        结果分析：a和c异步， a和b同步。原因：a b拿到同一把锁：class锁，c拿到的是对象锁
        
        
synchronized(class) 与在static方法上使用synchronized拿到的锁一样
    如现在将上面model中的printc方法改为：
        public void  printc(){
            synchronized (Model.class) {        //此时拿到的锁为class锁，与其他两个方法为同步方法
                System.out.println("线程名称：" + Thread.currentThread().getName());
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程名称：" + Thread.currentThread().getName());
            }
        }
            
    再次运行上面代码，运行结果：
        线程名称：a
        线程名称：a
        线程名称：c
        线程名称：c
        线程名称：b
        线程名称：b
            
    从结果可以看出，三个方法同步        
            
            
注意，如果使用字符串作为锁对象，相同的字符串锁对象相同


volatile关键字的使用：
    主要作用是使变量再多个线程间可见
    
    原理：变量被volatile修饰后，在获取此变量的值的时候，会强制从公共堆栈中取得变量的值，而不是从线程
    私有数据栈中取得变量的值
    
    volatile的线程安全问题：
        线程安全包含原子性和可见性两个方面，volatile保证了线程间的可见性，但不能保证线程间的原子性
        
补充：
    多线程的三个特性：原子性、可见性、有序性
    原子性：是指一个操作是不可中断的。即使是多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰。

    　　　　比如，对于一个静态全局变量int i，两个线程同时对它赋值，线程A给他赋值为1，线程B给他赋值为-1。那么不管这两个线程

    　　　　以何种方式。何种步调工作，i的值要么是1，要么是-1.线程A和线程B之间是没有干扰的。这就是原子性的一个特点，不可被中断。

    可见性：是指当一个线程修改了某一个共享变量的值，其他线程是否能够立即知道这个修改。显然，对于串行来说，可见性问题是不存在的。

    有序性：在并发时，程序的执行可能会出现乱序。给人的直观感觉就是：写在前面的代码，会在后面执行。有序性问题的原因是因为程序在

    　　　　执行时，可能会进行指令重排，重排后的指令与原指令的顺序未必一致。
            
                
    一、公共堆栈与线程的私有堆栈

    在启动线程时，变量的值是存在于公共堆栈及线程的私有堆栈中。在JVM被设置为-server 模式时为了线程运行的效率，
    线程一直在私有堆栈中取变量的值，即使有其他线程将变量的值进行了修改，更新的却是公共堆栈中的变量值，
    私有堆栈中的值不会变，这就导致线程运行存在问题