java - day018 - 线程续

• 生产者,消费者
• 线程间的通信模型

• 等待和通知
  • 在生产者和消费者模型中
  • 消费者暂停等待数据
  • 生产者产生数据后发出通知
  • object 方法
  • wait();
  • notify(); 通知一个
  • notifyAll();通知全部
  • 调用 stack.wait();
  • 当前线程,在stack 对象上等待
  • 调用 stack.notifyAll();
  • 在 stack 上发出通知,通知在 stack 对象上等待的线程
  • 注意:
  • 必须在 synchronized 同步代码快中调用
  • 必须在加锁的对象上等待或通知
  • synchronized (a) { a.wait(); a.notifyAll(); }
  • 为了保证安全, wait()外面总应该是一个循环判断 while

  • package day1802_生产者消费者;
    
    import java.util.Random;
    
    public class Producer extends Thread{
        private Stack stack;
    
        public Producer(Stack stack) {
            super();
            this.stack = stack;
        }
    
        @Override
        public void run() {
            super.run();
            while (true) {
                char c = (char)('a' + new Random().nextInt());
                synchronized (stack) {
    
                    while (stack.isFull()) {
                        try {
                            stack.wait();
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
    
                    stack.push(c);
                    System.out.println("压入>>"+c);
    
                    stack.notifyAll();
                }
    
            }
    
        }
    
    }

    package day1802_生产者消费者;
    
    public class Consumer extends Thread{
        private Stack stack;
    
        public Consumer(Stack stack) {
            super();
            this.stack = stack;
        }
    
        @Override
        public void run() {
            // TODO Auto-generated method stub
            super.run();
    
            while (true) {
                synchronized (stack) {
                    while (stack.isEmpty()) {
                        try {
                            stack.wait();
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
    
                    char c = this.stack.pop();
                    System.out.println("弹出>>"+c);
    
                    stack.notifyAll();
                }
    
            }
        }
    
    }

    package day1802_生产者消费者;
    
    public class Stack {
    
        private char[] a = new char[];
        private int index;
    
        public void push(char c) {
            if (isFull()) {
                return;
            }
    
            a[index] = c;
            index++;
        }
    
        public char pop() {
            if (isEmpty()) {
                return ' ';
            }
            index--;
            return a[index];
        }
    
        public boolean isEmpty() {
            // TODO Auto-generated method stub
            return index==;
        }
    
        public boolean isFull() {
            // TODO Auto-generated method stub
            return index==;
        }
    
    }

    package day1802_生产者消费者;
    
    import com.sun.swing.internal.plaf.synth.resources.synth;
    
    public class Test1 {
        public static void main(String[] args) {
            Stack stack = new Stack();
            Producer producer = new Producer(stack);
            Consumer consumer = new Consumer(stack);
    
            producer.start();
            consumer.start();
    
            // main 线程 死循环发通知
            while (true) {
                synchronized (stack) {
                    stack.notifyAll();
                }
            }
        }
    
    }

• 线程监视器模型
• 遇到 synchronized 关键字 ,在加锁的对象会关联一个同步监视器

• 网络通信
• window 终端输入 ipconfig
• mac 终端输入 ifconfig
• ping  192.168.4.xxx,  ping 不通, 关闭防火墙
• Socket 网络通信
• socket 网络套接字 (插头)
• 主机之间, 需要能用 IP地址,找到对方
• 在主机上选择一个端口, 来插插头(socket)
• 端口有 0 到 65535 个 端口
• 服务器端
  • 被动的等待客户端发起连接
  • 在一个端口上启动服务
• 客户端
• 向指定的服务器的 IP地址和端口号 发起连接,建立连接通道
• 连接通道的两端, 都有一个插头

• ServerSocket
• 启动服务
• ServerSocket ss = new ServerSocket(8000);
• 端口必须独占
• 0-1024,是常见服务的默认端口
• 50000之后是,是系统的保留端口来动态分配
• 方法
• accept()
• 暂停,等待客户端发起连接
• 建立与客户端的链接通道,并返回通道的服务器插头对象
• close()
• 停止服务, 释放端口

• 网络通信的阻塞操作
• ss.accept();// 阻塞暂停等待
• in.read();   // 阻塞,接收数据,对方不发送,死等
• 服务器端的线程模型