package com.itheima.thread.demo;



public class ResTest {

        /**
         * 1.线程间的通讯：多个线程处理同一资源，但是任务不同
         */

        public static void main(String[] args) {
                // TODO Auto-generated method stub
                Res r=new Res();
               
                Input in=new Input(r);
                Output out=new Output(r);
               
                Thread t1=new Thread(in);
                Thread t2=new Thread(out);
               
                t1.start();
                t2.start();

}

}
class Res{
        String name;
    String sex;
       
}
       //输入
        class Input implements Runnable{
                //Res rs=new Res();
                private Res r;
                Input(Res r){ //初始化动作传人要操作的内容
                   this.r=r;
                }
                @Override
                public void run() {
               
                        int x=0;
                        while(true){
                                if(x==0){
                                        r.name="小强";
                                        r.sex="男";
                                }else{
                                        r.name="小红";
                                        r.sex="女";
                                }
                                x=(x+1)%2;
                        }
                       
                }
                //System.out.println(r.name+"........"+r.sex);
        }
    //输出
        class Output implements Runnable{
                //Res rs=new Res();
                private Res r;
                Output(Res r){ //初始化传人要操作的内容
                   this.r=r;
                }
                @Override
                public void run() {
                        System.out.println(r.name+"........"+r.sex);
                       
                }
        }

//打印结果：小强........女
看老师视频敲得，怎么回这样的结果，应该是两个线程切换执行吧，求解。。。

因为Output类中的run方法没有循环，当然就只能看到一个结果了啊

1. package day2;
   
2. 
   
3. public class Test0 {
   
4.         /**
   
5.          * @param args
   
6.          */
   
7.         public static void main(String[] args) {
   
8.                 // TODO Auto-generated method stub
   
9.                 Res r=new Res();
   
10.         
    
11.         Input in=new Input(r);
    
12.         Output out=new Output(r);
    
13.         
    
14.         Thread t1=new Thread(in);
    
15.         Thread t2=new Thread(out);
    
16.         
    
17.         t1.start();
    
18.         t2.start();
    
19.         }
    
20. 
    
21. }
    
22. 
    
23.     /**
    
24.      * 1.线程间的通讯：多个线程处理同一资源，但是任务不同
    
25.      */
    
26. 
    
27.             // TODO Auto-generated method stub
    
28.             
    
29. 
    
30. 
    
31. class Res{
    
32.     String name;
    
33. String sex;
    
34.    
    
35. }
    
36.    //输入
    
37.     class Input implements Runnable{
    
38.             //Res rs=new Res();
    
39.             private Res r;
    
40.             Input(Res r){ //初始化动作传人要操作的内容
    
41.                this.r=r;
    
42.             }
    
43.             @Override
    
44.             public void run() {
    
45.             
    
46.                     int x=0;
    
47.                     while(true){
    
48.                             if(x==0){
    
49.                                     r.name="小强";
    
50.                                     r.sex="男";
    
51.                             }else{
    
52.                                     r.name="小红";
    
53.                                     r.sex="女";
    
54.                             }
    
55.                             x=(x+1)%2;
    
56.                     }
    
57.                     
    
58.             }
    
59.             //System.out.println(r.name+"........"+r.sex);
    
60.     }
    
61. //输出
    
62.     class Output implements Runnable{
    
63.             //Res rs=new Res();
    
64.             private Res r;
    
65.             Output(Res r){ //初始化传人要操作的内容
    
66.                this.r=r;
    
67.             }
    
68.             @Override
    
69.             public void run() {
    
70.                     while(true)
    
71.                     System.out.println(r.name+"........"+r.sex);//将这句话放进循环里就可以了。
    
72.             }
    
73.     }
    

复制代码

因为你的线程没有进行安全性处理，所以肯定出现问题，并不会按照交替打印的，贴上安全处理过的代码

1. class Res{
   
2.         private String name;
   
3.         private String sex;
   
4.         private boolean flag = false;
   
5. 
   
6.         public synchronized void set(String name,String sex){
   
7.                 if(flag)
   
8.                         try{this.wait();}catch(Exception e){}
   
9.                 this.name = name;
   
10.                
    
11.                 this.sex = sex;
    
12.                 flag = true;
    
13.                 this.notify()
    
14.         }
    
15.         public synchronized void out(){
    
16.                 if(!flag)
    
17.                         try{this.wait();}catch(Exception e){}
    
18.                 System.out.println(name+"........"+sex);
    
19.                 flag = false;
    
20.                 this.notify();
    
21.         }
    
22. }
    
23. 
    
24. class Input implements Runnable{
    
25.         private Res r ;
    
26.         Input(Res r){
    
27.                 this.r = r;
    
28.         }
    
29.         public void run(){
    
30.                 int x = 0;
    
31.                 while(true){
    
32.                         if(x==0)                                
    
33.                                 r.set("mike","man");                                
    
34.                         else        
    
35.                                 r.set("丽丽","女女女女女");                                
    
36.                         x = (x+1)%2;
    
37.                 }
    
38.         }
    
39. }
    
40. 
    
41. class Output implements Runnable{
    
42.         private Res r ;
    
43.         
    
44.         Output(Res r){
    
45.                 this.r = r;
    
46.         }
    
47.         public void run(){
    
48.                 while(true){
    
49.                         r.out();
    
50.                 }
    
51.         }
    
52. }

复制代码

多线程在共享变量的时候，一定保证变量使用的安全性。上面的例子中，当线程t1正在设置共享变量时，t2抢到了CPU的运行时间，便把t1还没有设置完全的两个变量都输出来了，这样就造成输出结果是一团糟的。为了防止这种结果，必须采用同步技术。最简单的方式是在对设置变量和输出变量的两个函数进行同步，即在方法面前均加上synchronized关键字。

//用synchronized加锁容易引起死锁，往往打印个一行或者一两行就不动了。
//下面的实现方案采用的是lock和condition的实现方式，锁及时进行释放，能够出现连续打印的效果

import java.util.concurrent.locks.*;

public class ResTest {
        public static void main(String[] args) {
                Res r = new Res();
                Input in = new Input(r);
                Output out = new Output(r);
                Thread t1 = new Thread(in);
                Thread t2 = new Thread(out);
                t1.start();
                t2.start();
        }
}

/*
* 1、将设置值和打印值的方法抽取到Res类中
* 2、在Res类中加锁
*/
class Res {
        private String name;
        private String sex;
        private boolean flag = false;
        private Lock lock = new ReentrantLock();
        private Condition con1 = lock.newCondition();
        private Condition con2 = lock.newCondition();

        public void set() {
                lock.lock();
                int x = 0;
                try {
                        while(true){
                                while (flag) {
                                        try {
                                                con1.await();
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }
                                }
                                if (x == 0) {
                                        this.name = "小强";
                                        this.sex = "男";
                                } else {
                                        this.name = "小红";
                                        this.sex = "女";
                                }
                                System.out.println("set:"+this.name + "........" + this.sex);
                                x = (x + 1) % 2;
                                con2.signal();
                                flag = true;
                        }
                } finally {
                        lock.unlock();
                }
        }

        public void out() {
                lock.lock();
                try {
                        while(true){
                                while (!flag) {
                                        try {
                                                con2.await();
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }
                                }
                                System.out.println("out:"+this.name + "........" + this.sex);
                                con1.signal();
                                flag = false;
                        }
                } finally {
                        lock.unlock();
                }
        }
}

// 输入
class Input implements Runnable {
        private Res r;

        Input(Res r) {
                this.r = r;
        }

        public void run() {
                r.set();
        }
}

class Output implements Runnable {
        private Res r;

        Output(Res r) {
                this.r = r;
        }

        public void run() {
                r.out();
        }
}

多谢各位啦，粗心一时没有考虑安全问题，操作共享变量要synchronized同步函数。。