多线程探讨着理解

1.无同步，非静态方法情况下的同一实例在多个线程中运行，操作同一静态变量。

结论：取得的值都是当前同一时刻静态变量的值，

     可能会导致在同一时间内多个线程轮流修改静态变量的值。

案例如下：

（1）主函数

package dna.network.payment.test.Thread;

/**

 *@ClassName:ThreadMainA

 *@author: chenyoulong  Email: chen.youlong@payeco.com

 *@date :2012-8-24 上午10:03:00

 *@Description:TODO

 */

publicclass ThreadMainA {

    publicstaticinta=5; //静态变量

    staticinti=3;

    /** 

     * @Title: main 

     * @Description: TODO 1.无同步情况下的同一实例在多个线程中运行操作同一静态变量。  结论：取得的值都是当前同一时刻静态变量的值，可能会导致在同一时间内多个线程轮流修改静态变量的值。

     * 

     *                    2.同步非静态变量

     * @param args 

     * @return void  

     */

    publicstaticvoid main(String[] args) {

         RunnableB rnb1=new RunnableB();//同一实例

              //启动多个线程

        while(i>0){

            // TODO Auto-generated method stub
//          RunnableB rnb2=new RunnableB();

            String name="A"+i;

            Thread th1=new Thread(rnb1, name);

            System.out.println("===="+name);

//          Thread th2=new Thread(rnb1, "B");

            th1.start();

//          th2.start();

            i--;

        }
    }
}

 

（2）继承Runnable接口

/**

 *@ClassName:RunnableB

 *@author: chenyoulong  Email: chen.youlong@payeco.com

 *@date :2012-8-24 上午10:02:21

 *@Description:TODO

 */

publicclass RunnableB implements Runnable {

    /* 

     * <p>Title: run</p> 

     * <p>Description: </p>  

     * @see java.lang.Runnable#run() 

     */

    publicvoid run() {

        // TODO Auto-generated method stub

        while(ThreadMainA.a>0 && ThreadMainA.a<10){

        option();

        }

    

    }

    

    /**

     * 

     * 非同步，非静态方法

     * @Title: option 

     * @Description: TODO  1.同一实例的同步方法，在不同线程中运行

     *                     2.全体有效

     *                     3.没有同步安全的

     * @return void

     */

    public   void option(){

        

        if("A1".equals(Thread.currentThread().getName())){

            System.out.println("A1执行qian===="+ThreadMainA.a);

        ThreadMainA.a++;

        System.out.println("A1增加执行后===="+ThreadMainA.a);

        } elseif("A2".equals(Thread.currentThread().getName())){

        System.out.println("A2执行qian===="+ThreadMainA.a);

        ThreadMainA.a++;

        System.out.println("A2增加执行后===="+ThreadMainA.a);

        } elseif("A3".equals(Thread.currentThread().getName())){

        System.out.println("A3执行qian===="+ThreadMainA.a);

        ThreadMainA.a++;

        System.out.println("A3增加执行后===="+ThreadMainA.a);

    }

        else{

        System.out.println("B执行qian===="+ThreadMainA.a);

        ThreadMainA.a--;

        System.out.println("B减执行后===="+ThreadMainA.a);

        }    

    }
}

 

运行结果：

 

 

2.有同步，非静态方法情况下的同一实例在多个线程中运行，操作同一静态变量 .

结论：达到线程安全的目的，数据都是一个线程操作完后另外一个线程才操作

 

案例：（1）主函数

/**

 *@ClassName:ThreadMainA

 *@author: chenyoulong  Email: chen.youlong@payeco.com

 *@date :2012-8-24 上午10:03:00

 *@Description:TODO

 */

publicclass ThreadMainA {

    publicstaticinta=5;  //同一变量

    staticinti=3;

    /** 

     * @Title: main 

     * @Description: TODO 1.无同步，非静态方法情况下的同一实例在多个线程中运行，操作同一静态变量。  结论：取得的值都是当前同一时刻静态变量的值，可能会导致在同一时间内多个线程轮流修改静态变量的值。

     *                    2.有同步，非静态方法情况下的同一实例在多个线程中运行，操作同一静态变量 . 结论：达到线程安全的目的，数据都是一个线程操作完后另外一个线程才操作

     * @param args 

     * @return void  

     */

    publicstaticvoid main(String[] args) {

         RunnableB rnb1=new RunnableB();  //同一实例

         //启动多个线程

        while(i>0){

            // TODO Auto-generated method stub        

//          RunnableB rnb2=new RunnableB();

            String name="A"+i;

            Thread th1=new Thread(rnb1, name);

            System.out.println("===="+name);

//          Thread th2=new Thread(rnb1, "B");

            th1.start();

//          th2.start();

            i--;

        } 

    }

}

 

（2）实现runnable接口

/**

 *@ClassName:RunnableB

 *@author: chenyoulong  Email: chen.youlong@payeco.com

 *@date :2012-8-24 上午10:02:21

 *@Description:TODO

 */

publicclass RunnableB implements Runnable {

 

    /* 

     * <p>Title: run</p> 

     * <p>Description: </p>  

     * @see java.lang.Runnable#run() 

     */

    publicvoid run() {

        // TODO Auto-generated method stub

        while(ThreadMainA.a>0 && ThreadMainA.a<10){

        option();

        }

    

    }

    

    /**
     *
     * @Title: option 
     * @Description: TODO  1.同一实例的同步方法，在不同线程中运行
     *                     2.全体有效
     *                     3.没有同步安全的
     * @return void
     */

    public  synchronized void option(){   //同步非静态方法

         if("A1".equals(Thread.currentThread().getName())){

            System.out.println("A1执行qian===="+ThreadMainA.a);

        ThreadMainA.a++;

        System.out.println("A1增加执行后===="+ThreadMainA.a);

        } elseif("A2".equals(Thread.currentThread().getName())){

        System.out.println("A2执行qian===="+ThreadMainA.a);

        ThreadMainA.a++;

        System.out.println("A2增加执行后===="+ThreadMainA.a);

        } elseif("A3".equals(Thread.currentThread().getName())){

        System.out.println("A3执行qian===="+ThreadMainA.a);

        ThreadMainA.a++;

        System.out.println("A3增加执行后===="+ThreadMainA.a);

    }

        else{

        System.out.println("B执行qian===="+ThreadMainA.a);

        ThreadMainA.a--;

        System.out.println("B减执行后===="+ThreadMainA.a);

        }    
    }
}

 

运行结果：

          2.有同步，非静态方法情况下的同一实例在多个线程中运行，操作同一静态变量图

 

 

3. 3.有同步，非静态方法情况下的多个实例在多个线程中运行，操作同一静态变量。  结论：同步非静态方法在多线程多实例的情况下失灵了。各自拥有自己的静态变量。

 

 

publicclass ThreadMainA {

    publicstaticinta=5;  //同一变量

    staticinti=3;

    /** 
     * @Title: main 

     * @Description: TODO 1.无同步，非静态方法情况下的同一实例在多个线程中运行，操作同一静态变量。  结论：取得的值都是当前同一时刻静态变量的值，可能会导致在同一时间内多个线程轮流修改静态变量的值。

    *                    2.有同步，非静态方法情况下的同一实例在多个线程中运行，操作同一静态变量 . 结论：达到线程安全的目的，数据都是一个线程操作完后另外一个线程才操作
     *                    3.有同步，非静态方法情况下的多个实例在多个线程中运行，操作同一静态变量。  结论：同步非静态方法在多线程多实例的情况下失灵了。各自拥有自己的静态变量。
    *                   
     * @param args 

     * @return void  

     */

    publicstaticvoid main(String[] args) {

        

         //启动多个线程

        while(i>0){

            // TODO Auto-generated method stub

              RunnableB rnb1=new RunnableB();  //多个实例

//          RunnableB rnb2=new RunnableB();

            String name="A"+i;

            Thread th1=new Thread(rnb1, name);

            System.out.println("===="+name);

            Thread th2=new Thread(rnb1, "B");

            th1.start();

            th2.start();

            i--;

        }

    }
}

 

 

（2）实现runnable接口

publicclass RunnableB implements Runnable {

 

    /* 

     * <p>Title: run</p> 

     * <p>Description: </p>  

     * @see java.lang.Runnable#run() 

     */

    publicvoid run() {

        // TODO Auto-generated method stub

        while(ThreadMainA.a>0 && ThreadMainA.a<10){

        option();

        }

    

    }

    

    /**
    * @Title: option 
     * @Description: TODO  1.同一实例的同步方法，在不同线程中运行
     *                     2.全体有效     *3.没有同步安全的                    
     * @return void

     */

    publicsynchronizedvoid option(){ //同步非静态方法

        

        if("A1".equals(Thread.currentThread().getName())){

            System.out.println("A1执行qian===="+ThreadMainA.a);

        ThreadMainA.a++;

        System.out.println("A1增加执行后===="+ThreadMainA.a);

        } elseif("A2".equals(Thread.currentThread().getName())){

        System.out.println("A2执行qian===="+ThreadMainA.a);

        ThreadMainA.a++;

        System.out.println("A2增加执行后===="+ThreadMainA.a);

        } elseif("A3".equals(Thread.currentThread().getName())){

        System.out.println("A3执行qian===="+ThreadMainA.a);

        ThreadMainA.a++;

        System.out.println("A3增加执行后===="+ThreadMainA.a);

    }

        else{

        System.out.println("B执行qian===="+ThreadMainA.a);

        ThreadMainA.a--;

        System.out.println("B减执行后===="+ThreadMainA.a);

        }    

    }

 

}

运行结果：

 

 

 

 

 

 

4.有同步，静态方法情况下的多个实例在多个线程中运行，操作同一静态变量。

（1）Main函数

publicclass ThreadMainA {

    publicstaticinta=5;  //同一变量

    staticinti=3;

    /** 
     * @Title: main 
     * @Description: TODO 1.无同步，非静态方法情况下的同一实例在多个线程中运行，操作同一静态变量。  结论：取得的值都是当前同一时刻静态变量的值，可能会导致在同一时间内多个线程轮流修改静态变量的值。
     *                    2.有同步，非静态方法情况下的同一实例在多个线程中运行，操作同一静态变量 . 结论：达到线程安全的目的，数据都是一个线程操作完后另外一个线程才操作

    *                    3.有同步，非静态方法情况下的多个实例在多个线程中运行，操作同一静态变量。  结论：同步非静态方法在多线程多实例的情况下失灵了。各自拥有自己的静态变量。

     *                    有同步，静态方法情况下的多个实例在多个线程中运行，操作同一静态变量。

     * @param args 
     * @return void  
     */

    publicstaticvoid main(String[] args) {

         //启动多个线程

        while(i>0){

            // TODO Auto-generated method stub

              RunnableB rnb1=new RunnableB();  //多个实例

            RunnableB rnb2=new RunnableB();

            String name="A"+i;

            Thread th1=new Thread(rnb1, name);

            System.out.println("===="+name);

            Thread th2=new Thread(rnb2, "B");

            th1.start();

            th2.start();

            i--;

        }
    }

}

 

 

（2）实现Runnable接口

 

publicclass RunnableB implements Runnable {

 

    /* 

     * <p>Title: run</p> 

     * <p>Description: </p>  

     * @see java.lang.Runnable#run() 

     */

    publicvoid run() {

        // TODO Auto-generated method stub

        while(ThreadMainA.a>0 && ThreadMainA.a<10){

        option();

        }

    

    }

    

    /**

     * 

     * 

     * @Title: option 

     * @Description: TODO  1.同一实例的同步方法，在不同线程中运行

     *                     2.全体有效

     *                     3.没有同步安全的

     * @return void

     */

    publicstaticsynchronizedvoid option(){ //同步静态方法

        

        if("A1".equals(Thread.currentThread().getName())){

            System.out.println("A1执行qian===="+ThreadMainA.a);

        ThreadMainA.a++;

        System.out.println("A1增加执行后===="+ThreadMainA.a);

        } elseif("A2".equals(Thread.currentThread().getName())){

        System.out.println("A2执行qian===="+ThreadMainA.a);

        ThreadMainA.a++;

        System.out.println("A2增加执行后===="+ThreadMainA.a);

        } elseif("A3".equals(Thread.currentThread().getName())){

        System.out.println("A3执行qian===="+ThreadMainA.a);

        ThreadMainA.a++;

        System.out.println("A3增加执行后===="+ThreadMainA.a);

    }

        else{

        System.out.println("B执行qian===="+ThreadMainA.a);

        ThreadMainA.a--;

        System.out.println("B减执行后===="+ThreadMainA.a);

        }    

    }

 

}

 

运行结果：