黑马程序员技术交流社区

标题: 单例设计模式解决这个问题 [打印本页]
作者: 长石    时间: 2014-1-14 19:39
标题: 单例设计模式解决这个问题
这是毕老师在视频提的一个例子  用synchronized解决多线程安全问题  
他说用单例设计模式也可以  但我试了几回都不对  求大神帮解决


  2. class Res{
  3.         String name;
  4.         String sex;
  5. }
  6. class Input implements Runnable{
  7.         private Res r;
  8.         public  Input(Res r){
  9.                 this.r = r;
  10.         }
  11.         public void run(){
  12.                 int x =0;
  13.                 while(true){
  14.                         synchronized(r){
  15.                                 if(x==0){
  16.                                         r.name = "mike";
  17.                                         r.sex = "男";
  18.                                 }else{
  19.                                         r.name = "lily";
  20.                                         r.sex = "女";
  21.                                 }
  22.                                
  23.                         }
  24.                         x = (x+1)%2;
  25.                 }
  26.         }
  27. }
  28. class Output implements Runnable{
  29.         private Res r;
  30.         public Output(Res r){
  31.                 this.r = r;
  32.         }
  33.         public void run(){
  34.                 while(true){
  35.                         synchronized(r){
  36.                                 System.out.println(r.name+"---"+r.sex);
  37.                         }
  38.                 }
  39.         }
  40. }
  41. public class InputOutputDemo01 {

  43.         public static void main(String[] args) {
  44.                 Res r = new Res();
  45.                
  46.                 Input in = new Input(r);
  47.                 Output out = new Output(r);
  48.        
  49.                 Thread t1 = new Thread(in);
  50.                 Thread t2 = new Thread(out);
  51.                 t1.start();
  52.                 t2.start();
  53.         }
  54. }
复制代码
作者: 几番意难相付    时间: 2014-1-14 20:27
本帖最后由 几番意难相付 于 2014-1-14 20:32 编辑

  2. <P>class test
  3. {
  4.         public static void main(String[] args){
  5.                 new Thread(new input()).start();
  6.                 new Thread(new output()).start();
  7.         }
  8. }

  10. class input implements Runnable
  11. {
  12.         person p=person.getInstance();
  13.         public void run(){
  14.                  int x =0;
  15.                 while(true){
  16.                                 synchronized(p){
  17.                                         if(x==0){
  18.                                                         p.name = "张三";
  19.                                                         p.sex = "男";
  20.                                         }else{
  21.                                                         p.name = "lili";
  22.                                                         p.sex = "女";
  23.                                         }
  24.                                 }
  25.                         x = (x+1)%2;
  26.                 }
  27.         }
  28. }
  29. class output implements Runnable
  30. {
  31.         person p=person.getInstance();
  32.         public void run(){
  33.                 while(true){
  34.             synchronized(p){
  35.                    System.out.println(p.name+"---"+p.sex);
  36.             }
  37.         }
  38.         }
  39. }</P>
  40. <P> </P>
  41. <P>//所谓的单例
  42. class person
  43. {</P>
  44. <P>        //将该类的构造方法私有
  45.         private person(){}</P>
  46. <P>      //在本类中创建一个本类的对象
  47.         private static person p=new person();</P>
  48. <P>     //定义静态方法 返回上面创建的本类对象 即使这个方法被多次调用 返回的也只是在本类中创建的这个对象 保证了唯一性
  49.         public static person getInstance(){
  50.                 return p;
  51.         }
  52.         String name;
  53.         String sex;
  54. }</P>
复制代码
作者: 长石    时间: 2014-1-15 09:31
你没明白我的  毕老师是说  这个例子不用synchronized  用单例设计模式也可以解决同步问题
作者: 长石    时间: 2014-1-15 09:37
几番意难相付 发表于 2014-1-14 20:27

你没明白我的  毕老师是说  这个例子不用synchronized  用单例设计模式也可以解决同步问题
作者: ❦_H_t    时间: 2014-1-15 09:40
线程同步好像必须用到synchronized或者Lock,老师说的单例模式应该是指输入输出共同操作的资源吧?你倒回去仔细看看视频?
作者: 几番意难相付    时间: 2014-1-15 10:29
长石 发表于 2014-1-15 09:31
你没明白我的  毕老师是说  这个例子不用synchronized  用单例设计模式也可以解决同步问题 ...

那是你会错意了，毕老的意思并不是说单例可以代替同步，而是说，单例可以保证一个对象在内存中的唯一性。
原例中说，是让两个线程共同操作同一个资源。着重点是“同一个资源”，而不是同步。
然后学生说，用单例。这时候的语境，是相当于“同一个资源”而言的，并不是说，单例能解决线程安全。
然后毕老说，用单例可以，但是单例麻烦。他用的是在主函数中创建一个资源的对象，然后将这一个资源对象，作为参数传递给不同的线程执行操作。这样，多个线程操作的，只能是在主函数里建立的那唯一一个资源对象。
单例，上面说了，保证了对象在内存中的唯一性。也就相当于在主函数里建立一个对象分别给不同的线程操作。


线程安全问题，只能用同步，别无他法。要么synchronized，要么lock，再没有什么能够代替这两个。
作者: 长石    时间: 2014-1-15 12:37
几番意难相付 发表于 2014-1-15 10:29
那是你会错意了，毕老的意思并不是说单例可以代替同步，而是说，单例可以保证一个对象在内存中的唯一性。 ...

谢谢耐心解答
作者: LDstruggling    时间: 2015-10-26 21:09
这么长，啊，看不下去。。。。。。。



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2