java学习进阶之 一 （线程基础）

一、线程安全

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

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

示例：【com.study.base.thread.a_sync.sync001】MyThread

package com.study.base.thread.a_sync.sync001;
/**
 * 
 *        线程安全概念：当多个线程访问某一个类（对象或方法）时，这个类始终都能表现出正确的行为，那么这个类（对象或方法）
 *    就是线程安全的
 *        synchronized:可以在任意对象及方法上加锁，而加锁的这段代码称为“互斥区”或“临界区”
 *    
 *    示例总结
 *        当多个线程访问myThread的run方法时，以排队的方式进处理（这里排队是按照CPU分配的先后顺序商定的），
 *    一个线程想要执行Synchronized修饰的方法里的代码，首先是尝试获得锁，如果拿到锁，执行synchronized代码体内容；
 *    拿不到锁，这个线程就会不断的尝试获得这把锁，直到拿到为止，而且是多个线程同时去竞争这把锁（也就是会有锁竞争的问题）。
 */
public class MyThread implements Runnable {
    private int count = 5;
    
    //synchronized 加锁
    public synchronized void run() {
        count--;
        System.out.println(Thread.currentThread().getName()+" count = "+count);
    }
    
    public static void main(String[] args) {
        /**
         *     分析：
         *         当多个线程访问myThread的run方法时，以排队的方式进行处理（这里排队是按照cpu分配的先后顺序而定的）
         *         1  尝试获得锁
         *         2 如果拿到锁，执行synchronized代码体内容：拿不到锁出，这个线程就会不断的尝试获得这把锁，直到拿到为止
         *         而且是多个线程同时去竞争这把锁，也就是会有锁竞争的问题
         */
        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();
         
    }
}

MyThread

示例总结

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

二、多个线程多个锁

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

示例：【com.study.base.thread.a_sync.sync002】MultiThread

package com.study.base.thread.a_sync.sync002;
/**
 *     多个线程多个锁：多个线程，每个线程都可以拿到自己指定的锁分别获得锁之后执行synchronized方法体的内容
 *        关键字synchronized获取的锁都是对象锁，而不是把一段代码（方法）当做锁，所以示例代码中哪个线程先执行synchronized关键字的方法，哪个线下就持有该方法所属对象的锁（Lock），两个对象。线程获得的就是两个不同的锁，他们互不影响
 *    有一种情况则是相同的锁，即使在静态方法上加synchronized关键字，表示锁定.class，类一级别的锁（独占.class类）.
 */
public class MultiThread {
    private int num = 0;
    public synchronized void printNum(String tag) {
        try {
            if(tag.equals("a")) {
                num = 100;
                System.out.println("tag a , set num over");
                Thread.sleep(1000);
            } else {
                num = 200 ;
                System.out.println("tag b , set num over");
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("tag "+tag+" , num = "+num);
    }
    //注意观察run方法的输出顺序
    public static void main(String[] args) {
        //两个不同的对象
        final MultiThread m1 = new MultiThread();
        final MultiThread m2 = new MultiThread();
        
        Thread t1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                m1.printNum("a");
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                m2.printNum("b");
            }
        },"t2");
        t1.start();
        t2.start();
    }
}

MultiThread

示例总结

    关键字synchronized获取的锁都是对象锁，而不是把一段代码（方法）当做锁，所以示例代码中哪个线程先执行synchronized关键字的方法，哪个线下就持有该方法所属对象的锁（Lock），两个对象。线程获得的就是两个不同的锁，他们互不影响 有一种情况则是相同的锁，即使在静态方法上加synchronized关键字，表示锁定.class，类一级别的锁（独占.class类）.

三、对象锁的同步和异步

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

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

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

　　原子性（同步）

　　可见性

示例：【com.study.base.thread.a_sync.sync003】MyObject

package com.study.base.thread.a_sync.sync003;
/**
 * 
 * 对象的同步和异步问题
 *
 */
public class MyObject {
    public synchronized void method1() {
        try {
            System.out.print(Thread.currentThread().getName());
            Thread.sleep(4000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /** synchronized */
    public void method2() {
        System.out.println(Thread.currentThread().getName());
    }
    
    public static void main(String[] args) {
        final MyObject mo = new MyObject();
        /**
         * 分析：
         * t1线程先持有object对象的lock锁，t2线程可以以异步的方式调用对象中的非synchronized修饰的方法
         * t1线程先持有object对象的lock锁，t2线程如果在这个时候调用对象中的同步（synchronized）方法则需等待，也就是同步
         */
        Thread t1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                mo.method1();
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            
            @Override
            public void run() {
                // TODO Auto-generated method stub
                mo.method2();
            }
        },"t2");
        t1.start();
        t2.start();
    }
}

MyObject

示例总结

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

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

四、脏读

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

示例：【com.study.base.thread.a_sync.sync004】DirtyRead

package com.study.base.thread.a_sync.sync004;

/**
 * 业务整体需要使用完整的synchronized，保持业务的原子性
 * 
 *
 */
public class DirtyRead {
    private String username = "Rang";
    private String password = "123";
    public synchronized void setValue(String username, String password) {
        this.username = username;
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        this.password = password;
        
        System.out.println("setValue最终结果, username = " + username + " password = " + password);
    } 
    
    public synchronized void getValue() {
        System.out.println("getValue方法得到, username = " + username + " password = " + password);
    }
    
    public static void main(String[] args) throws InterruptedException {
        
        final DirtyRead dr = new DirtyRead();
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                dr.setValue("z3", "456");
            }
            
        },"t1");
        t1.start();
        Thread.sleep(1000);
        
        dr.getValue();
        
    }
            
}

DirtyRead

示例总结：

    在我们对一个对象的方法加锁的时候，需要考虑业务的整体性，即为setValue / getValue 方法同时加锁synchronized同步的关键字，保证业务（service）的原子性，不然会出现业务错误（也从侧面保证业务的一致性）。