2018-01-21 18:45:27    157    0    0

学完这些就可以上天了

2018-01-15 18:34:20    176    0    0

链路层的主要功能包括链路管理、帧同步、流量控制、差错控制、数据和控制信息分开、透明传输和寻址。

2018-01-14 15:34:30    175    0    0

信道:向某一个方向传送信息的媒体。
信号:数据的电磁或电气表现。
带宽:媒介中信号可使用的最高频率和最低频率之差,或者说是频带的宽度;另一个定义是信道中数据的传送速率。
码元:在使用时域的波形表示数字信号时,代表不同离散数值的基本波形。
波特:单位时间内传输的码元数。
比特率:单位时间内传输的比特数。

电路交换、报文交换、分组交换

电路交换必定是面向连接的。
电路交换的三个阶段:建立连接、通信和释放连接。

分组交换的优点:
高效:动态分配传输带宽,对通信链路是逐段占用。
灵活:以分组为传送单位和查找路由。
迅速:不必建立连接就能向其他主机发送分组。
可靠:保证可靠性的网络协议;分布式的路由选择协议使网络有很好的生存性。

分组交换的缺点:
分组在各结点存储转发时需要排队,这就会造成一定的时延。
分组必须携带的首部(里面有必不可少的控制信息)也造成了一定的开销。

分组交换虚电路服务与数据报服务的对比
图片标题

2018-01-13 19:09:50    179    0    0

计算机网络:把地理位置不同的具有独立功能的多台计算机及其外部设备,通过通信线路连接起来,在网络操作系统,网络管理软件及网络通信协议的管理和协调下,实现资源共享和信息传递的计算机系统。

核心部分:网络、路由器,包括物理层、数据链路层和网络层。
边缘部分:主机,包括传输层和应用层。

广域网WAN(Wide Area Network)
局域网LAN(Local Area Network)
城域网MAN(Metropolitan Area Network)

网络协议(network protocol),简称为协议,是为进行网络中的数据交换而建立的规则、标准或约定。

网络协议的三要素:
1. 语义(Semantics):数据与控制信息的结构或格式
2. 语法(Syntax):需要发出何种控制信息,完成何种动作以及作出何种响应
3. 同步即定时(Timing):事件实现顺序的详细说明

接口(服务访问点)
同一系统中相邻两层的实体进行交互的地方。

服务(service)
为保证上层对等体之间能相互通信,下层向上层提供的功能。

实体(entity)表示任何可发送或接受信息的硬件或软件进程。
协议是控制两个对等实体进行通信的规则的集合。

本层的服务用户只能看见服务而无法看见下面的协议。
下面的协议对上面的服务用户是透明的。
协议是水平的,即协议是控制对等实体之间通信的规则。
服务是垂直的,即服务是由下层向上层通过层间的接口提供的。

ISO/OSI参考模型
应用层、表示层、会话层、传输层、网络层、数据链路层、物理层

TCP/IP模型
应用层、传输层、网际层、网络接口层

五层协议的体系结构
应用层、传输层、网络层、数据链路层、物理层

2018-01-08 14:09:57    125    0    0

输入输出是按照Java程序(而不是硬盘)为参照物而言的,输入流读取数据,输出流写出数据。
字节流
字符流:为了方便操作文本数据(1个字符2个字节),Windows自带的记事本打开不乱码就用字符流。

  1. import java.io.FileOutputStream;
  2. import java.io.IOException;
  3. /**
  4. * Created by sakura on 2018/1/8.
  5. */
  6. /*
  7. * IO流的分类:
  8. * 流向:
  9. * 输入流 读取数据
  10. * 输出流 写出数据
  11. * 数据类型:
  12. * 字节流
  13. * 字节输入流 读取数据 InputStream
  14. * 字节输出流 写出数据 OutputStream
  15. * 字符流
  16. * 字符输入流 读取数据 Reader
  17. * 字符输出流 写出数据 Writer
  18. *
  19. * 注意:如果没有明确说明按哪种分类来说,默认情况下是按照数据类型来分的。
  20. *
  21. * 需求:向一个文本文件中输入一句话:"hello,IO"
  22. */
  23. public class FileOutputStreamDemo {
  24. public static void main(String[] args) throws IOException {
  25. // 创建字节输出流对象
  26. FileOutputStream fos = new FileOutputStream("fos.txt");
  27. //写数据
  28. fos.write("hello,IO".getBytes());
  29. //释放资源,关闭此文件输出流并释放与此流有关的所有系统资源。
  30. fos.close();
  31. }
  32. }

FileOutputStream的write方法

  1. import java.io.FileOutputStream;
  2. import java.io.IOException;
  3. /*
2018-01-06 22:24:27    149    0    0
2018-01-04 21:18:46    172    0    0

1. final、finally和finalize的区别
final:
被final修饰的类不能被继承;
被final修饰的方法不能被重写;
被final修饰的变量不能被更改。

finally:
是异常处理的一部分,用于释放资源。
一般来说,finally里面的代码一定会执行,除非在finally之前调用System.exit()方法终止JVM的运行。

finalize:
是Object类的一个方法,用于垃圾回收。
引用深入理解JVM一书中的一段话:
即使在可达性分析算法中不可达的对象,也并非是“非死不可”的,这时它们暂时处于“缓刑”阶段,要真正宣告一个对象死亡,至少要经理两次标记过程:如果对象在进行可达性分析后发现没有与GC Roots相连接的引用链,那它会被第一次标记并且进行一次筛选,筛选的条件是此对象是否有必要执行finalize()方法。当对象没有覆盖finalize()方法,或者finalize()方法已经被虚拟机调用过,虚拟机把这两种情况都视为“没有必要执行”。如果这个对象被判定为有必要执行finalize()方法,那么这个对象会被放置在一个叫F-Queue的队列之中,并在稍后由一个由虚拟机自动建立的、低优先级的Finalizer线程去执行它。这里所谓的“执行”是指虚拟机会触发这个方法,但并不承诺会等待它运行结束(防止发生死循环)。finalize()方法是对象逃脱死亡命运的最后一次机会,稍后GC会对F-Queue中的对象进行第二次标记,如果对象在finalize()方法中成功拯救自己——只要重新和引用链上的任何一个对象建立关联即可,那么在第二次标记时它会被移除出“即将回收”的集合,如果对象这个时间点还没有逃脱,那基本上它就真的被回收了。

2. 如果catch里面有return语句,那么finally里面的代码还会执行吗?执行顺序?
finally语句是在try的return语句执行之后,return返回之前执行。

  1. import java.util.ArrayList;
  2. import java.util.List;
  3. /**
  4. * Created by sakura on 2018/1/4.
  5. */
  6. public cla
2018-01-04 19:54:34    176    0    0

File类:文件和目录(文件夹)路径名的抽象表示形式。
构造方法

  1. import java.io.File;
  2. /**
  3. * Created by sakura on 2018/1/7.
  4. */
  5. public class FileDemo {
  6. public static void main(String[] args) {
  7. // File(String pathname):根据一个路径得到File对象
  8. // 把e:\\demo\\a.txt封装成一个File对象
  9. File file = new File("E:\\demo\\a.txt");
  10. // File(String parent, String child):根据一个目录和一个子文件/目录得到File对象
  11. File file2 = new File("E:\\demo", "a.txt");
  12. // File(File parent, String child):根据一个父File对象和一个子文件/目录得到File对象
  13. File file3 = new File("e:\\demo");
  14. File file4 = new File(file3, "a.txt");
  15. // 以上三种方式其实效果一样
  16. }
  17. }

创建

  1. import java.io.File;
  2. import java.io.IOException;
  3. /**
  4. * Created by sakura on 2018/1/7.
  5. */
  6. /*
  7. *创建功能:
  8. *public boolean createNewFile():创建文件 如果存在这样的文件,就不创建了
  9. *public boolean mkdir():创建文件夹 如果存在这样的文件夹,就不创建了
  10. *public boolean mkdirs():创建文件夹,如果父文件夹不存在,会帮你创建出来
  11. */
  12. public class FileDemo {
  13. public static void main(String[] args) throws IOException {
2018-01-03 22:29:01    199    0    0

第1章 简介

1. 并发简史
早期的计算机不包含操作系统,从头到尾执行一个程序,并且这个程序能访问计算机中的所有资源。缺点:不易编写和运行程序,且浪费资源。
操作系统的出现使得计算机每次能运行多个程序,并且不同的程序都在独立的进程中运行:操作系统为各个独立执行的进程分配各种资源。
之所以在计算机中加入操作系统来实现多个程序的同时执行,主要是基于以下原因:
A. 资源利用率:避免IO操作陷入等待造成的后续程序无法执行,在等待的同时运行另一个程序,那么无疑会提高资源利用率。
B. 公平性:不同的用户和程序对于计算机上的资源有着同等的使用权。
C. 便利性:只编写一个程序计算所有任务不易实现。
线程会共享进程范围内的资源,但每个线程都有各自的PC、栈以及局部变量等。线程也被称为轻量级进程。操作系统是以线程(而不是进程)作为基本的调度单位。

2. 线程的优势
A. 发挥多核处理器的性能,避免资源浪费。
B. 把一种类型的任务放到一个线程中完成,而不是所有的任务在一起执行,更加容易实现。
C. 服务器可以为每一个连接都分配一个线程(同步IO),而不是一个线程完成几个连接(非阻塞IO),更加简单。
D. 多线程使得执行任务的时间变得更加短暂,提高了GUI界面的灵敏度。

3. 线程带来的问题
A. 安全性问题

  1. @NotThreadSafe
  2. public class UnsafeSequence{
  3. private int value;
  4. //返回一个唯一的值
  5. public int getNext(){
  6. return value++;
  7. }
  8. }

由于value++并不是单个操作(原子操作),包括了三个独立的操作:
1.读取value
2.value+1
3.把计算结果写回value
这样在多线程的情况下就会出现竞态问题(Race Condition)。
图片标题
或者说是缓存一致性问题,即线程B在执行value++时,并没有读取到value的最新的数据(读取到的9是脏数据),从而产生非预期的结果。

  1. @ThreadSafe
  2. public class Sequence{
  3. private int v
2017-12-30 19:19:20    186    0    0

定义:为其他对象提供一种代理以控制对这个对象的访问。代理对象起到中介作用,可去掉功能服务或增加额外的服务(火车票代售处)。
远程代理(客户端服务器模式)
虚拟代理(网站图片延迟加载)
保护代理(控制用户的访问权限)
智能引用代理(火车票代售处)
接下来用静态代理和动态代理两种方式实现智能引用代理。

静态代理:代理和被代理对象在代理之前是确定的,它们都实现相同的接口或者继承相同的抽象类。
1. 没用代理模式之前
Moveable

  1. package com.sakura.proxy;
  2. /**
  3. * Created by sakura on 2017/12/30.
  4. */
  5. public interface Moveable {
  6. void move();
  7. }

Car

  1. package com.sakura.proxy;
  2. import java.util.Random;
  3. /**
  4. * Created by sakura on 2017/12/30.
  5. */
  6. public class Car implements Moveable {
  7. @Override
  8. public void move() {
  9. long starttime=System.currentTimeMillis();
  10. System.out.println("汽车开始行驶...");
  11. //实现开车
  12. try {
  13. Thread.sleep(new Random().nextInt(1000));
  14. System.out.println("汽车行驶中...");
  15. } catch (InterruptedException e) {
  16. e.printStackTrace();
  17. }
  18. long endtime=System.currentTimeMillis();
  19. System.out.println("汽车结束行驶...汽车行驶时间:"+(endtime-starttime)+"毫秒!");
  20. }
  21. }

Client