本实验主要考察多线程对单例模式的操作，和多线程对同一资源的读取，两个知识。实验涉及到三个类：

1)一个pojo类Student，包括set/get方法。

2)一个线程类，设置student的成员变量age和name的值为111和111

3）另一个线程类，设置student的成员变量age和name的值为222和2222

4）main类，for循环200次，分别创建200个线程1和线程2对同一资源访问。（共400个线程）

 

1.第一种情况：饿汉式单例模式保证多线程操控的是同一对象

//饿汉式单例模式pojo类 public class Student {    private String age = "12";    private String name = "Tome";        private static Student student = new Student();//类加载时候创建对象        public String getNameAndAge() {        return name+":"+age;    }     public void setNameAndAge(String name,String age) {        this.name = name;        this.age = age;    }    private Student() //构造函数私有化    {            }    public static Student GetInstace() { //方法区函数，静态函数            return student;    }}

线程2类：

public class MyThread extends Thread {    @Override    public void run() {        // TODO Auto-generated method stub        System.out.println(Student.GetInstace().hashCode());    }}

测试类，创建并启动400个线程：

public class AppMain implements Runnable{    public static void main(String[] args) {        AppMain appMain = new AppMain();        for(int i =0;i<200;i++)        {        Thread thread1 = new Thread(appMain);//线程1        MyThread thread2 = new MyThread();//线程2        thread1.start();        thread2.start();        }    }        @Override    public void run() {        // TODO Auto-generated method stub        System.out.println(Student.GetInstace().hashCode());    }}

结果：

 

2.第二种情况：共享资源的写方法不设置任何同步，多个线程可以交叉写数据

public String getNameAndAge() {        return name+":"+age;    }     public void setNameAndAge(String name,String age) { //没有设置任何写同步        this.name = name;        this.age = age;    }

俩线程操控类：

public class MyThread extends Thread {    @Override    public void run() {        // TODO Auto-generated method stub        Student.GetInstace().setNameAndAge("111", "111");//设置name和age值为1         System.out.println(Student.GetInstace().getNameAndAge(););    }}

线程2

public class AppMain implements Runnable{   public static void main(String[] args) {        AppMain appMain = new AppMain();        for(int i =0;i<200;i++)        {        Thread thread1 = new Thread(appMain);        MyThread thread2 = new MyThread();        thread1.start();        thread2.start();        }    }        @Override    public void run() {        // TODO Auto-generated method stub        Student.GetInstace().setNameAndAge("222", "2222");//设置name和age为2         System.out.println(Student.GetInstace().getNameAndAge(););    }}

执行结果：

3.第三种情况：共享资源的写方法设置同步synchronized，保证同一时刻只有一个线程才能执行写，执行完后才释放锁。

public String getNameAndAge() {        return name+":"+age;    }    synchronized public void setNameAndAge(String name,String age) { //写方法设置synchronized了        this.name = name;        this.age = age;    }

测试类添加打印：

public static void main(String[] args) {        AppMain appMain = new AppMain();        for(int i =0;i<200;i++)        {        Thread thread1 = new Thread(appMain);        MyThread thread2 = new MyThread();        thread1.start();        thread2.start();        System.out.println(Student.GetInstace().getNameAndAge());//添加打印，显示name和age值        }    }

这样就能多个线程按序设置name和set值了。但为什么测试结果依然有脏数据呢？比如111：222这种脏数据呢？

答案：因为没设置单例对象读get方法的锁，这样读方法可以随时获取值，即使set线程还没执行完，因为没有synchronized限制可以随时访问。

4.第四种情况，共享资源的读方法不同步不synchronized，方便随时读取不受锁的限制。但就像之前说的，会读到写线程还没执行完时的数据，造成数据混乱。因为读线程可以随时读，没有锁的限制。

public String getNameAndAge() { //读方法没有做同步synchronized处理，可以随时读取，就可以读出写线程未执行完的中间数据        return name+":"+age;    }    synchronized public void setNameAndAge(String name,String age) {        this.name = name;        this.age = age;    }

操作结果：

5.第五种情况，读方法也设置synchronized，锁的对象也是this。保证写的时候不能读，保证读的时候不能写。即读写用同一个锁。

synchronized public String getNameAndAge() {        return name+":"+age;    }    synchronized public void setNameAndAge(String name,String age) {        this.name = name;        this.age = age;    }

测试结果：

这样数据就全部准确了，但是这样效率很低，因为读写共同设置一个锁。读的时候不能写，写的时候不能读。全部都是按序来访问。

结论：当多线程共同访问同一资源时候，此共享对象的读写方法，要都设置同一个锁，保证写的时候不能读，读的时候不能写，且读写都是按序执行。才能保证数据的准确性。

同时，也说明了，没有设置锁的方法可以随时执行，随时执行，随时可能被cpu调度以至打断线程的执行，以至读到线程执行一半产生的脏数据。