JAVA多线程学习2--线程同步

一、线程同步介绍

　　同步：就是协同步调，按照预定的先后顺序执行。比如：你说完我再说。

　　线程同步：访问同一个共享资源的时候多个线程能够保证数据的安全性、一致性。

二、JAVA中实现线程同步的方法

　　实现进程同步的方法是在共享竞争的资源上加锁，保证对资源的独占性。JAVA中通过关键字synchronized实现同步。看下面的例子

package cn.edu.sdust.AsyTest;



public class TestAsyn implements Runnable {

    

    Timer timer = new Timer();



    /**

     * @param args

     */

    

    public void run(){

        timer.add(Thread.currentThread().getName());

    }

    

    public static void main(String[] args) {

        // TODO Auto-generated method stub



        TestAsyn test1 = new TestAsyn();

        

        Thread t1 = new Thread(test1);

        Thread t2 = new Thread(test1);

        t1.setName("t1");

        t2.setName("t2");

        t1.start();

        t2.start();

    }

    

}





class Timer{

    

    int num=0;

    public  void add(String name){

        num++;

        try {

            Thread.sleep(1); //使当前线程睡眠，切换线程

        } catch (InterruptedException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        System.out.println(name+"这是线程"+num);

        

    }

}

运行结果：

t1这是线程2

t2这是线程2

分析：这是因为当线程t1执行后修改了num=1后睡眠，线程t2执行，修改num=2后睡眠，切换到线程t1执行，此时num已经为2，因此打印t1为第二个线程。显然这种结果不是我们想要的。

如何保证数据的安全性，这里需要对共享资源加锁，实现线程同步。将共享资源add()方法加上关键字synchronized，保证资源的独占性。如下

class Timer{

    

    int num=0;

    public synchronized void add(String name){

        num++;

        try {

            Thread.sleep(1); //使当前线程睡眠，切换线程

        } catch (InterruptedException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        System.out.println(name+"这是线程"+num);

        

    }

}

修改后运行结果：

t1这是线程1

t2这是线程2

解释：通过synchronized对add方法进行加锁，即使通过sleep使线程t1睡眠，线程t1仍然握有该资源的锁，因此t2不能执行，必须等t1执行完释放对资源的锁t2才能执行。（注：sleep与wait区别之一就是sleep后线程仍然握有资源的锁，而wait后线程将会放弃资源的锁，直到被唤醒后重新争夺资源的锁）

三、synchronized的一些特点

　　当线程握有synchronized加锁的资源的锁时，其他访问非加锁资源的线程能够执行。如下例子：

public class ThreadAsynchronmous  implements Runnable{



    int n=100;

    

    public synchronized void   m1(){

        System.out.println("m1");

        n=1000;

        try{

        Thread.sleep(5000);

        }catch (InterruptedException e){

            e.printStackTrace();

        }

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

    }

    public  void m2() throws Exception{

        

        System.out.println("------"+n);

    }

    

    public void run(){

        m1();

    }

    /**

     * @param args

     * @throws Exception 

     */

    public static void main(String[] args) throws Exception {

        // TODO Auto-generated method stub

        ThreadAsynchronmous t=new ThreadAsynchronmous();

        

        new Thread(t).start();

        Thread.sleep(1000);        //让线程非主线程先执行，执行m1

        

    /*    for(int i=0; i<100; i++){

            System.out.println(i);

        }*/    

        t.m2();
　　　　//System.out.println(n);

    }



}

运行结果:

m1

------1000

n=1000

可以看到在加锁线程执行的同时，主线程仍然可以继续执行，非加锁资源仍然可以被执行。因此，不要在非加锁区对共享变量做修改。以防止数据的不安全、不一致。