JavaSE 第二次学习随笔(四)

public void wu() {
        Runnable r1 = () -> {
            ThreadA();
        };
        Runnable r2 = () -> {
            ThreadB();
        };

        new Thread(r1).start();
        new Thread(r2).start();
    }


    private int numa = 11;
    private int numb = 0;
    public synchronized void ThreadA() {
        while (numa + numb == 11 && numa > 1) {
            numa--;
            try {
                System.out.println("ThreadA:" + numa);
                this.wait(3);
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                this.notifyAll();
            }
        }
    }

    public synchronized void ThreadB() {
        while (numa  + numb + 1== 11 && numb < 10) {
            numb++;
            try {
                System.out.println("ThreadB:" + numb);
                this.wait(3);
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                this.notifyAll();
            }
        }
    }

class SingleInstance {
    private static SingleInstance singleInstance2 = null;
    private SingleInstance() {}
    public static SingleInstance getSingleInstance() {
        if(singleInstance2 == null){
            synchronized(SingleInstance.class) {
                if(singleInstance2 == null) {
                    singleInstance2 = new SingleInstance();
                }
            }
        }
        return singleInstance2;
    }
}	

public class Demo2 {
    public static void main(String[] args) {
        Obj o = new Obj();
        Thread p1 = new Thread(new Producer(o));
        Thread p2 = new Thread(new Producer(o));
        Thread p3 = new Thread(new Producer(o));
        Thread p4 = new Thread(new Producer(o));
        Thread c1 = new Thread(new Customer(o));
        Thread c2 = new Thread(new Customer(o));
        Thread c3 = new Thread(new Customer(o));
        Thread c4 = new Thread(new Customer(o));
        p1.start();
        c1.start();
        p2.start();
        c2.start();
        p3.start();
        c3.start();
        p4.start();
        c4.start();
    }

}

class Obj {
    public int num = 0;

    public Obj() {
    }

    public Obj(int num) {
        this.num = num;
    }

    public int getNum() {
        return num;
    }

    public synchronized void setNum(int num) {
        this.num = num;
    }
}


class Producer implements Runnable {
    volatile Obj o = null;

    public Obj getO() {
        return o;
    }

    public void setO(Obj o) {
        this.o = o;
    }

    public Producer() {
    }

    public Producer(Obj o) {
        this.o = o;
    }

    @Override
    public void run() {
        while (true) {
            if (o.getNum() > 30) {
                synchronized (o) {
                    System.out.println(Thread.currentThread().getName() + "唤醒消费停止生产");
                    o.notify();
                    try {
                        o.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            if (o.getNum() < 30) {
                synchronized (o) {
                    if (o.getNum() < 30) {
                        o.setNum(o.getNum() + 1);
                        System.out.println(Thread.currentThread().getName() + "生产, 还剩余" + o.getNum());
                    }
                }
            }
        }
    }
}

class Customer implements Runnable {
    volatile Obj o = null;

    public Customer(Obj o) {
        this.o = o;
    }

    public Customer() {
    }

    public Obj getO() {
        return o;
    }

    public void setO(Obj o) {
        this.o = o;
    }

    @Override
    public void run() {
        long a = System.nanoTime();
        while (true) {
            if (o.getNum() <= 0) {
                synchronized (o) {
                    System.out.println(Thread.currentThread().getName() + "唤醒生产停止消费");
                    o.notify();
                    try {
                        o.wait();
                        a = System.nanoTime();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            if (o.getNum() > 0) {
                synchronized (o) {
                    if (o.getNum() > 0) {
                        o.setNum(o.getNum() - 1);
                        System.out.println(Thread.currentThread().getName() + "消费, 还剩余" + o.getNum() +" "+ (System.nanoTime() - a));
                    }
                }
            }
        }
    }
}
		
		
	2.多线程多消费者多生产者(无论多少生产者消费者, 生产一次消费一次)
public class Demo4 {
    public static void main(String[] args) {
        Dat d = new Dat();
        Runnable r1 = new P(d);
        Runnable r2 = new C(d);

        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        Thread t3 = new Thread(r1);
        Thread t4 = new Thread(r2);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

class Dat {
    int num = 2;
    private Lock lock = new ReentrantLock();
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();

    public void inc() {
        while (true){
            try {
                lock.lock();
                while (num % 2 == 0) {
                    c1.await();
                }
                num++;
                System.out.println(Thread.currentThread().getName() + "Inc" + num);
                c2.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    public void dec() {
        while (true) {
            try {
                lock.lock();
                while(num %2 != 0) {
                    c2.await();
                }
                num--;
                System.out.println(Thread.currentThread().getName() + "Dec" + num);
                c1.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

}

class P implements Runnable {
    Dat d = null;

    @Override
    public void run() {
        d.inc();
    }

    public P(Dat d) {
        this.d = d;
    }

}

class C implements Runnable {
    Dat d = null;

    @Override
    public void run() {
        d.dec();
    }

    public C(Dat d) {
        this.d = d;
    }
}
		
	(另一种方式, 加标记方式)	
		try {
			lock.lock();
			while (flag == false) {
				try {
					//wait();
					conditionCon.await();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			
			System.out.println(Thread.currentThread().getName()+"  消费了:"+name+"  产品的数量:"+count+"  产品的价格:"+price);
			
			flag = !flag;
			
			//唤醒生产线程
			//notify();
			//notifyAll();
			conditionPro.signal();
		} finally {
			lock.unlock();
		}
		
		

        //创建字符写出流
		FileWriter fileWriter = new FileWriter("test");
		//使用字符缓冲流实现写出
		BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
		//写的操作
		bufferedWriter.write("asdf");
		//bufferedWriter.write("\r\n");//windows下的换行
		bufferedWriter.newLine();//换行,可以实现跨平台        

　　　　　　//a:一次读一个字符
		int num;
				while ((num = bufferedReader.read()) != -1) {
					System.out.print((char)num);
				}
		//b:一次读多个字符
				char[] arr = new char[2];
				while ((num = bufferedReader.read(arr)) != -1) {
					System.out.print(new String(arr,0,num));
				}
		//c:一次读一行  readLine()
		//原理:一个字符一个字符的读,直到读到换行符为止.然后将所有读到的字符返回
		//注意点:不会将当前的换行符返回 ;返回值就是我们读到的内容.如果读完了,返回null
		String data = null;
		while ((data = bufferedReader.readLine()) != null) {
			System.out.print(data);
			System.out.println();//换行
		}

//		字节流的写入
        FileOutputStream fileOutputStream = new FileOutputStream("d:\\fileWrite.txt");
//        因为是使用的字节流不能直接使用字符, 需要进行编码
        fileOutputStream.write("fileWrite".getBytes());
		
//		字节流读入(单个读取)
		FileInputStream fileInputStream = new FileInputStream("d:\\fileWrite.txt");
//        因为是使用的字节流不能直接使用字符, 需要进行编码
        int num =0;
        while ((num = fileInputStream.read())!= -1){
            System.out.print((char) num);
        }

//		字节流读入(以数组读取)
		FileInputStream fileInputStream = new FileInputStream("d:\\fileWrite.txt");
//        因为是使用的字节流不能直接使用字符, 需要进行编码
        byte [] bs = new byte[3];
        while ((fileInputStream.read(bs))!= -1){
            System.out.print(new String(bs));
        }
		
//		InputStream的 available()方法获取文件字节数
		FileInputStream fileInputStream = new FileInputStream("d:\\fileWrite.txt");
//        如果文本字节数大不建议使用
        byte [] bs = new byte[fileInputStream.available()];
        while ((fileInputStream.read(bs))!= -1){
            System.out.println(new String(bs));
        }

BufferedReader keyBoardAsInput = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter consoleAsOutput = new BufferedWriter(new OutputStreamWriter(System.out));
BufferedReader fileAsInput = new BufferedReader(new FileReader("d:\\test"));
BufferedWriter fileAsOutput = new BufferedWriter(new FileWriter("d:\\testok",true));	//可追加

System.setIn(new FileInputStream("d:\\test"));
System.setOut(new PrintStream("d:\\testok"));
BufferedReader keyBoardAsInput = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter consoleAsOutput = new BufferedWriter(new OutputStreamWriter(System.out));