线程池 锁 、

• 线程安全类和不安全类

   

  • StringBuffer类是线程安全的类，但StringBuilder类不是线程安全的类。
  • Vector类和Hashtable类是线程安全的类，但ArrayList类和HashMap类不是线程安全的类。
  • Collections.synchronizedList() 和Collection.synchronizedMap()等方法实现安全。

• 死锁的概念

  • 

• 使用Lock锁实现线程同步

  • 
  • 这四个方法为了实现线程与线程之间的通信的

• 线程池：

  • 线程之间的通信实现

  • package com.lagou.task18;
    
    public class ThreadCommunicateTest implements Runnable{
        int cnt = 1;
        @Override
        public void run() {
            while (true){
                synchronized (this) {
                        //每当有一个线程进来后，先大喊一声把对方叫醒，，调用notify方法
                        notify();
                    if (cnt <= 100){
                        System.out.println("线程" + Thread.currentThread().getName() + "中cnt=：" + cnt);
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        cnt++;
                        //当前线程打印完毕一个整数后，，为了防止继续打印下一个数据，调用wait方法
                        try {
                            wait();//当前线程进入阻塞状态，自动释放对象锁，必须在锁定的代码中运行。
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }else{
                        break;
                    }
                }
            }
        }
    
        public static void main(String[] args) {
    
            ThreadCommunicateTest tct = new ThreadCommunicateTest();
            Thread t1 = new Thread(tct);
            t1.start();
            Thread t2 = new Thread(tct);
            t2.start();
        }
    }

• 生产者消费者模型

• 创建线程的第三种方式

  • 实现Callable接口

• 线程池的概念和由来

  • 

• package com.lagou.task18;
  
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  
  public class ThreadPoolTest {
      public static void main(String[] args) {
          //1.创建一个线程池
          ExecutorService ets = Executors.newFixedThreadPool(10);
          //2.向线程池中布置任务
          ets.submit(new ThreadCallableTest());
          //3.关闭线程池
          ets.shutdown();
      }
  }
  

• 任务总结

  • 线程
    • 概念、创建方式、线程的生命周期、线程的编号和名称、常用的方法、线程的同步、Synchronized关键字、线程的通信、生产者消费者模型、线程池等多

• 网络编程：

  • 七层网络模型
  • 应用层、表示层、会话层、传输层、网络层、数据链路层、物理层
  • 相关的协议：
  • 
  • tcp慢点可靠、udp快速不可靠
  • 

  • 客户端和服务器不断通信的代码实现

  • package com.lagou.task19;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class ServerStringTest {
        public static void main(String[] args) {
            ServerSocket ss = null;
            Socket s = null;
            BufferedReader br = null;
            PrintStream ps = null;
            try {
                //1.创建ServerSocket类类型的对象并提供端口号
                ss = new ServerSocket(8888);
                //2.等待客户端的连接请求，调用accept方法
                //等待客户端的连接请求
                System.out.println("等待客户端的连接请求。。");
                //当没有客户端连接是，，服务器阻塞在Accept方法的调用这里
                s = ss.accept();
                System.out.println("客户端连接成功");
    
    
                //3.使用输入输出流进行通信
                //实现对客户端发来字符串内容的接受并打印
                //通过循环实现对客户端数据内容的不断接受回复！
                    br = new BufferedReader(new InputStreamReader(s.getInputStream()));
                    ps = new PrintStream(s.getOutputStream());
                while (true) {
                    String s1 = br.readLine();
                    System.out.println("客户端发来的字符串内容是：" + s1);
                    if ("bye".equalsIgnoreCase(s1)){
                        System.out.println("客户端已下线！");
                        break;
                    }
                    //实现服务器向客户端回发字符串内容"i received"
                    ps.println("i received");
                    System.out.println("服务器发送数据成功");
                }
    
    
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (null != ps){
                    ps.close();
                }
                if (null != br){
                    try {
                        br.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                //4.关闭Socket并释放相关资源
                if (null != s) {
                    try {
                        s.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (null != ss) {
                    try {
                        ss.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
    
            }
        }
    }
    

    package com.lagou.task19;
    
    import java.io.*;
    import java.net.Socket;
    import java.util.Scanner;
    
    public class ClientStringTest {
        public static void main(String[] args) {
            Socket s = null;
            PrintStream ps = null;
            Scanner sc = null;
            BufferedReader bw = null;
            try {
                //1.创建socket类型的对象并提供服务器的主机名和端口号
                s = new Socket("127.0.0.1",8888);
                System.out.println("连接服务器成功！");
    
                //2.使用输入输出流进行通信
                //Thread.sleep(10000);
                //实现客户端发送的内容由用户从键盘输入
                //循环实现不断的发送数据接收数据
                    sc = new Scanner(System.in);
                    ps = new PrintStream(s.getOutputStream());
                    bw = new BufferedReader(new InputStreamReader(s.getInputStream()));
                while (true) {
                    System.out.println("请如数要发送的数据内容");
                    String str1 = sc.next();
                    //实现客户端向服务器发送字符串内容"Hello"
                    //ps.println("hello");
                    ps.println(str1);
                    System.out.println("客户端发送数据内容成功");
                    if ("bye".equals(str1)){
                        System.out.println("聊天结束！");
                        break;
                    }
                    //实现接受服务器发来的数据内容
                    String s1 = bw.readLine();
                    System.out.println("服务器回发的消息是：" + s1);
                }
    
    
            } catch (IOException /*| InterruptedException*/ e) {
                e.printStackTrace();
            } finally {
                if (null != bw){
                    try {
                        bw.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (null != sc){
                    sc.close();
                }
                //3.关闭Socket并释放相关的资源
                if (null != s) {
                    try {
                        s.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (null != ps){
                    ps.close();
                }
    
            }
        }
    }