Java多线程中synchronized关键字的使用方法

关于多线程Thread方法的几点总结,待续~

1.isAlive方法判断线程是否存活 ,wait方法传入参数0无限期等待
2.yield方法让出cpu执行权大家再次公平竞争
3.join方法等待线程执行完一起运行，比如子线程运行循环累加，主线程运行at.join(0),一直等他累加完,主线程在运行下面的打印语句,相当于主线程在等待子线程的运行完成
4.守护进程不主导虚拟机的运行，守护进程设置方法为thread.daemon(true),必须在start方法前，不然抛错且无效，如果main中只有设置守护线程且start，不论线程中如何写死循环，程序直接结束
5.多线程中的关于synchronize关键字使用
注意notify wait以及相对应的两个all方法都是Object对象的方法,必须拿到锁之后才能执行这些方法

指定对象加锁,进入同步代码前需要获得给定对象的锁 TestSyn.java  代码解释请看注释

package com.gzr.study;

/**
 * 
 * @author gzr
 *  synchronized 关键字
 *  制定加锁对象 :指定对象加锁,进入同步代码前需要获得给定对象的锁 TestSyn.java
 *  直接作用于实例方法:相当于对当前实例加锁 需要获得当前实例的锁  TestSyn2.java
 *  直接作用于静态方法:相当于对当前类加锁,进入同步代码钱需要获得当前类的锁 SimpleWaitNotify.java
 */

public class TestSyn implements Runnable{

    /**
     * testSyn为实例对象作为锁
     */
    static TestSyn testSyn=new TestSyn();
    static int i=0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(testSyn);
        Thread t2=new Thread(testSyn);
        t1.start();t2.start();
        /**
        * t1 t2执行完之后 主线程在运行打印语句
        */
        t1.join();t2.join();
        System.out.println(i);
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int j=0;j<100;j++) {
            synchronized (testSyn) {
                i++;
            }
        }
    }

}

直接作用于实例方法:相当于对当前实例加锁 需要获得当前实例的锁  TestSyn2.java

package com.gzr.study;


/**
 * 
 * @author gzr
 *  synchronized 关键字
 *  制定加锁对象 :指定对象加锁,进入同步代码前需要获得给定对象的锁 TestSyn.java
 *  直接作用于实例方法:相当于对当前实例加锁 需要获得当前实例的锁  TestSyn2.java
 *  直接作用于静态方法:相当于对当前类加锁,进入同步代码钱需要获得当前类的锁 SimpleWaitNotify.java
 */

public class TestSyn2 implements Runnable{

    /**
     * testSyn为实例对象作为锁
     */
    static TestSyn2 testSyn=new TestSyn2();
    static int i=0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(testSyn);
        Thread t2=new Thread(testSyn);
        /*
         * 这是错误的调用方法因为作用于实例方法上的,必须是同一实例才能同步,这里new到两个对象不会产生同步效果
         * Thread t1=new Thread(new TestSyn2());
        Thread t2=new Thread(new TestSyn2());*/
        t1.start();t2.start();
        t1.join();t2.join();
        System.out.println(i);
    }

    /**
     * synchronized关键字作用于方法上
     */
    public synchronized void increase() {
        i++;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int j=0;j<10000;j++) {
            increase();
        }
    }

}

直接作用于静态方法:相当于对当前类加锁,进入同步代码钱需要获得当前类的锁 SimpleWaitNotify.java

package com.gzr.study;


public class SimpleWaitNotify {
    final static Object object=new Object();

    public static class T1 extends Thread{

        @Override
        public void run() {
            // TODO Auto-generated method stub
            /**
             * object.wait();放在这里运行会报错
             */
            synchronized (object) {
                System.out.println(System.currentTimeMillis()+",T1 start");
                try {
                    System.out.println(System.currentTimeMillis()+",T1 wait");
                    /**
                     * 注意wait和notify等方法都必须在你拿到锁之后才有资格做
                     * t1 放弃刚才拿到的锁对象,大家重新开始竞争锁 
                     * 在哪wait就在哪醒
                     */
                    object.wait();
                } catch (Exception e) {
                    // TODO: handle exception
                    e.printStackTrace();
                }
                System.out.println(System.currentTimeMillis()+",T1 End");
            }
        }

    }

    public static class T2 extends Thread{

        @Override
        public void run() {
            // TODO Auto-generated method stub
            synchronized (object) {
                System.out.println(System.currentTimeMillis()+",T2 start");
                try {
                    /**
                     * notify会随机唤醒一个拥有当前锁的监视器的进程,这里只有t1所以唤醒t1
                     * notify唤醒t1 让他有机会拿到锁执行下去
                     */
                    object.notify();
                    System.out.println(System.currentTimeMillis()+",T2 notify");
                    System.out.println(System.currentTimeMillis()+",T2 End");
                    /**
                     * 完了之后休眠2秒,t2 End两秒之后 t1 End被打印
                     */
                    Thread.sleep(2000);
                    /**
                     * t2 放弃刚才拿到的锁对象,大家重新开始竞争锁 
                     * 在哪wait就在哪醒
                     */
                } catch (Exception e) {
                    // TODO: handle exception
                    e.printStackTrace();
                }

            }
        }

    }

    public static void main(String[] args) {
        Thread t1=new T1();
        Thread t2=new T2();
        t1.start();t2.start();
        /**
         * 运行结果如下
         * 1512191804823,T1 start
            1512191804824,T1 wait
            1512191804824,T2 start
            1512191804824,T2 notify
            1512191804824,T2 End
            1512191806825,T1 End

            T2 End两秒后T1 End
         */
    }

}