Java多线程的研究

最近看了些关于多线程的文章，感觉还没有很深刻地理解，决定自己动手写几个例子来测试一下，加深对多线程的理解。

基础入门：Java的锁是针对某个对象或者某个类，即是对象锁和类锁。
对象锁：1.非静态的同步方法. 2.synchronized(object) 3. synchronized(this)
类锁： 1.静态的同步方法(static synchronized) . 2. synchronized(XXX.class)

需要注意的点：
1.非静态的同步方法 和 synchronized(this) 是等效的，调用该方法的对象会被作为锁，直到该同步方法执行完成。同步代码块比直接在方法上使用synchronized的性能更好。
2.静态的同步方法(static synchronized) 是以该方法所在的类作为锁。synchronized(XXX.class)是以XXX.class作为锁，当XXX.class 和 静态同步方法所在的类是同一个类时，两者是等效的。

public class ThreadModel {


    public static synchronized void doBackGroundClass(int count) {
        for (int i = 0; i < count; i++) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("doBackGroundClass -------> " + count + " 执行完毕");
    }


    public synchronized void doBackGround(int count) {
        for (int i = 0; i < count; i++) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("doBackGround -------> " + count + " 执行完毕");
    }

}

创建一个ThreadModel类，里面分别有两个方法，一个是静态同步方法doBackGroundClass，另一个是非静态的同步方法doBackGround

public static void main(String[] args) {
        new Thread() {
            @Override
            public void run() {
                //类锁
                ThreadModel.doBackGroundClass(1000);
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                //对象锁
                ThreadModel threadModel = new ThreadModel();
                threadModel.doBackGround(10);
            }
        }.start();
    }

执行结果如下

doBackGround -------> 10 执行完毕
doBackGroundClass -------> 1000 执行完毕

结果分析：静态同步方法和非静态同步方法之间并不会完成同步，因为两者的锁并非同一把锁，一个是以ThreadModel.class作为锁，另一个是以new ThreadModel()对象作为锁，不同的锁之间不能完成同步。

public static void main(String[] args) {
        new Thread() {
            @Override
            public void run() {
                //类锁
                ThreadModel.doBackGroundClass(1000);
            }
        }.start();

        new Thread() {
            @Override
            public void run() {

                ThreadModel.doBackGroundClass(10);

                //对象锁
//                ThreadModel threadModel = new ThreadModel();
//                threadModel.doBackGround(10);
            }
        }.start();
    }

执行结果如下

doBackGroundClass -------> 1000 执行完毕
doBackGroundClass -------> 10 执行完毕

结果分析：ThreadModel类的静态同步方法都是共用ThreadModel.class作为锁，所以Java类的中的所有静态同步方法之间都是会完成同步的。

 public static void main(String[] args) {
        new Thread() {
            @Override
            public void run() {

                ThreadModel threadModel = new ThreadModel();
                threadModel.doBackGround(1000);
                //类锁
//                ThreadModel.doBackGroundClass(1000);
            }
        }.start();

        new Thread() {
            @Override
            public void run() {

//                ThreadModel.doBackGroundClass(10);

                //对象锁
                ThreadModel threadModel2 = new ThreadModel();
                threadModel2.doBackGround(10);
            }
        }.start();
    }

执行结果

doBackGround -------> 10 执行完毕
doBackGround -------> 1000 执行完毕

结果分析：threadModel 和 threadModel2 在内存中是完全两个不同的对象，不同的对象锁之间是不会完成同步的。

public static void main(String[] args) {
        ThreadModel threadModel = new ThreadModel();

        new Thread() {
            @Override
            public void run() {
                //对象锁
                threadModel.doBackGround(1000);
                //类锁
//                ThreadModel.doBackGroundClass(1000);
            }
        }.start();

        new Thread() {
            @Override
            public void run() {

//                ThreadModel.doBackGroundClass(10);

                //对象锁
                threadModel.doBackGround(10);
            }
        }.start();
    }

执行结果

doBackGround -------> 1000 执行完毕
doBackGround -------> 10 执行完毕

结果分析：同一个对象锁会产生互斥，完成同步

思考题：

修改代码如下

public static synchronized void doBackGroundClass(int count) {
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < count; i++) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("doBackGroundClass -------> " + count + " 执行完毕");
            }
        }.start();
    }


    public synchronized void doBackGround(int count) {
        new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < count; i++) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("doBackGround -------> " + count + " 执行完毕");
            }
        }.start();
    }

  public static void main(String[] args) {
        ThreadModel threadModel = new ThreadModel();
        threadModel.doBackGround(1000);
        threadModel.doBackGround(10);
    }
}

如果程序这样执行，能同步吗？

doBackGround -------> 10 执行完毕
doBackGround -------> 1000 执行完毕

答案是不能！因为这样写已经不存在多线程同步问题了，doBackGround(1000)和.doBackGround(10) 都是在主线程里执行的，他们是顺序执行的。在方法内部，又开启了一个新的线程，所以产生了异步，10比1000先执行完成 。