JavaSE第十四天




复习:
线程:
   两种实现方式:
       extends  Thread   
       implements Runnable 不是线程类
   构造方法:
       Thread();
       Thread(String name);
       Thread(Runnable r);
       Thread(Runnable r,String name)
   常用方法:
       run()线程体方法
       start()启动线程
       currentThread()返回正在执行的线程对象
       getName()返回线程的名称
       sleep() 线程休眠
       join()等待线程执行结束
   生命周期:
       新建状态:new Thread()
       就绪状态:start()
       阻塞状态:sleep(),wait(),io,解除,重新排队
       运行状态:run()执行方法,自动执行的
       消亡状态:执行完run方法
   优先级:
       系统自动分配:5
       人为设置:
   调度:
       不同优先级:高优先级先执行,低后
       同一优先级:先到先服务
   线程同步:
       共享变量不安全
       synchronized
        synchronized(锁对象){
           
        }
        synchronized修饰方法
   同步线程之间的通信问题
       wait()
       notify();
       notifyAll();
-------------------------------------------------------------
sleep和wait的区别

   sleep线程类的方法       wait是Object类的方法
   sleep方法不是释放锁     wait是释放锁
   sleep方法自动醒         wait必须使用notify,notifyAll唤醒
 

线程的死锁
StringBuffer str1 = new StringBuffer();
        StringBuffer str2 = new StringBuffer();
        synchronized (str1) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            synchronized (str2){
                System.out.println("str1");
                System.out.println("str2");
            }
        }
        synchronized (str2) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            synchronized (str1){
                System.out.println("str1");
                System.out.println("str2");
            }
        }

线程池
   为什么使用线程池
     频繁的创建线程,需要耗费时间和内存
   使用线程池的好处:
     管理线程
     使线程重用

package cn.tedu.demo.thread;

import java.text.DateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ThreadPoolDemo {
    //创建一个线程池,如果线程池中的线程数量过大,它可以有效的回收多余的线程,
    //            如果线程数不足,那么它可以创建新的线程。
    public static void test1() throws Exception {
        
        ExecutorService threadPool = Executors.newCachedThreadPool();
    
        for (int i = 0; i < 5; i++) {
    
            final int index = i;
    
            Thread.sleep(1000);
            //完成5个任务
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "  " + index);
                     try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            });
        }
    }
    //指定线程池中的线程数,线程数是可以进行控制的
    public static void test2() throws InterruptedException {
        
       // ExecutorService threadPool = Executors.newFixedThreadPool(1);
        ExecutorService threadPool =
                Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
    
            Thread.sleep(1000);
            final int index = i;
    
            threadPool.execute(() -> {
                try {
                    Thread.sleep(2 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "  " + index);
            });
        }
        threadPool.shutdown();//不关闭正在执行的线程
          //threadPool.shutdownNow();//不管线程是否执行完毕,立即停止执行
          System.out.println("关闭线程!");
    }
    //线程池支持定时周期性任务执行
    public static void test3() {
        ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(5);
    
        threadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                long start = new Date().getTime();
                System.out.println("scheduleAtFixedRate 开始执行时间:" +
                        DateFormat.getTimeInstance().format(new Date()));
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                long end = new Date().getTime();
                System.out.println("scheduleAtFixedRate 执行花费时间=" + (end - start) / 1000 + "m");
                System.out.println("scheduleAtFixedRate 执行完成时间:" + DateFormat.getTimeInstance().format(new Date()));
                System.out.println("======================================");
            }
        }, 1, 5, TimeUnit.SECONDS);
    }
    //单线程池,至始至终都由一个线程来执行
    public static void test4() {
    
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
    
        for (int i = 0; i < 5; i++) {
            final int index = i;
            threadPool.execute(() -> {
                try {
                    Thread.sleep(2 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "   " + index);
            });
        }
       // threadPool.shutdown();
    }
    
    public static void main(String[] args) throws Exception {
        test2();

    }

}
-------------------------------------------------------------
网络编程概述
    计算机网络:


    网络模型(OSI开放式系统互联。国际标准组织制定了OS七层网络模型I(Open System Interconnection)模型)
                  OSI七层网络模型
        物理层 数据链路层 网络层 传输层 会话层 表示层 应用层
        
    协议:事先规定好的通信规则
        
        协议分类:共有的,私有的
                网络层:ip
                传输层:udp,tcp
                应用层:ftp http https。。。

    IP地址
        IP地址:表示网络上的唯一一台计算机
        IP地址分为两个版本:
                  IPv4    IPv6
            
    端口:0-65535    (0-1024)预留的
        
    域名解析:localhost(www.163.com):127.0.0.1(72.1.1.1)
        

java中的网络编程
    
    1.UDP通信 -- 写信
        不需要创建连接
        通过发送数据包通信 每个数据包最大64KB
        不可靠的传输机制
        传输速度比较快
        追求速度快 可靠性要求不高的场景下 - 视频聊天

        
    2.TCP通信 -- 打电话
        需要先创建连接 - 并且在创建连接的过程中 需要经过三次握手
        底层通过 流 发送数据 数据没有大小限制
        可靠的传输机制 - 丢包重发 包的顺序的保障
        传输速度相对比较慢
        对于速度要求不太高 但是对可靠性要求比较高的场景下 - 文件上传 下载

        因为TCP在通信的过程中 是需要创建连接的 连接的发起者称为客户端 监听端口等待被连接的一端称为服务端

服务器端的核心代码

    //1.创建套接字对象
        ServerSocket serverSocket=
                new ServerSocket(5555);
        System.out.println("等待客户端的请求。。。。。");
        //2.调用accept方法,接收请求
        Socket socket = serverSocket.accept();
        System.out.println("接收到一个客户端的请求。。。。。。");
        //3.获取输入流对象,读客户端的数据
        InputStream in = socket.getInputStream();
        BufferedReader br =
                new BufferedReader(
                    new InputStreamReader(in));
        String msg = br.readLine();
        System.out.println(msg);
        //4.处理后的结果通过输出流,写出去
        msg = msg+ " hello,client!";
        OutputStream out = socket.getOutputStream();
        PrintStream pw = new PrintStream(out);
        pw.println(msg);
        pw.flush();
        
        //5.关闭流,套接字对象
        br.close();
        pw.close();
        socket.close();
        serverSocket.close();

 客户端的代码:
     //1.创建套接字对象
        Socket socket = new Socket("localhost",5555);
        //2.获取输出流,写信息
        OutputStream out =
                socket.getOutputStream();
        PrintStream pw =
                new PrintStream(out);
        pw.println("hello server!");
        pw.flush();
        //3.获取输入流,读信息
        InputStream in = socket.getInputStream();
        BufferedReader br =
                new BufferedReader(
                        new InputStreamReader(in));
        String msg = br.readLine();
        System.out.println(msg);
        //4.关闭流
        
        pw.close();
        br.close();
        socket.close();    


    
        案例(了解):实现 文件 上传服务器

posted on 2020-08-03 19:21  Winer_Jiu  阅读(108)  评论(0编辑  收藏  举报

导航