Tag Archives: Java

TCP三次握手与四次挥手

Leave a reply

说明

  1. TCP在建立连接与断开连接时报文头部的标志位与序号值分别是多少呢？
  2. 利用Java的Socket对象分别实现客户端与服务端，对进通讯过程进行数据报文捕获；
  3. 分别研究两种情况，一种是服务器与客户端都在本机，另一种是分别位于两台机器上；

Java示例代码

Client

// packag[......]
继续阅读

Java多线程中的线程安全问题

Leave a reply

多个线程访问共享数据就会产生冲突的问题，以卖票为例，多个窗口卖同一批票就会出现重复卖的问题

  public static void main(String[] args) {
      Runnable runnable = new Runnable() {
          Integer tickets = 100;
          @Override
          public void run() {
              String name = Thread.currentThread().getName();
              while(tickets-- > 0) {
                  try {
                      Thread.sleep(1);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
                  System.out.println(name + "正在卖票: " + tickets);
              }
          }
      };
      new Thread(runnable).start();
      new Thread(runnable).start();
      new Thread(runnable).start();
  }

解决方案一：使用同步机制，共享部分同步执行则不会出现重复操作问题

  1. synchronized关键字实现代码块同步 
    public static void main(String[] args) {
    Object lock = new Object();
    Runnable runnable = new Runnable() {
        Integer tickets = 100;

        @Override
        public void run() {
            String name = Thread.currentThread().getName();
            while (true) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock) {
                    if (tickets <= 0) break;
                    System.out.println(name + "正在卖票: " + tickets);
                    tickets--;
                }
            }
        }
    };
    new Thread(runnable).start();
    new Thread(runnable).start();
    new Thread(runnable).start();
}
  2. synchronized同步方法实现同步机制 
    static Integer tickets = 100;
public static void main(String[] args) {
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            while (true) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                sellTicked();
                if (tickets <= 0) break;
            }
        }
    };
    new Thread(runnable).start();
    new Thread(runnable).start();
    new Thread(runnable).start();
}

synchronized private static void sellTicked() {
    if (tickets <= 0) return;
    String name = Thread.currentThread().getName();
    System.out.println(name + "正在卖票: " + tickets);
    tickets--;
}

解决方案二：使用锁，ReentrantLock
[……]

继续阅读

Java基本语法的几个笔记

Leave a reply

1 需要注意的点

1.1 运算赋值操作

  1. 复合赋值运算中(如：+=、-=等)，隐含了类型强制转换。如： 
    byte b = 126;
// 按常理2是int型，byte + int 结果应该是int，但这里会强转为byte
b += 2;  // 结果会溢出
System.out.println(b); // -128
  2. 三目运算不能单独存在，运算结果必须要有“接收方” 
    OperationDemo.java:10: 错误: 不是语句
               a > b ? a : b;
                     ^
1 个错误
  3. 整数类型中byte、short、int、long四种的前三种在运算时都会先转换为int类型； 
    byte a = 10;
byte b = 20;
// 事实上是byte = int + int，所以编译时会报错
byte ret = a + b;

    OperationDemo.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失
               byte ret = a + b;
                            ^
1 个错误
  4. 如果表达式的右边为常量，编译时会先将表达的进行计算，用结果替换原来的表达式，如： 
    // 上述示例中ret = a + b，表达式右边是int型，左边是byte，有转换失真的风险所以编译会报错；
// 但如果右边是常量则不会，byte ret = 10 + 20类似直接写byte ret = 30;
byte ret = 10 + 20;

1.2 函数与方法

  1. 方法重载中如果返回值类型不一样，不构成方法重载。(想想看，返回值是可以强制类型转换的，那么编译器到底该给哪个方法呢？所以此处有歧异) 
    public static int sum(int a, int b) {
   return a + b;
}
// 编译报错，方法重名了，仅返回值类型不同不构成方法重载
public static float sum(int a, int b) {
   return (float) (a + b);
}

1.3 数组

  1. 数组初始化的几种方式，主要有静态初始化(指定值)与动态初始化(指定长度)；
  • 所谓的静态与动态区别是即时指定长度还是直接赋值；
  • Java中指定值有两种方式，一种是类型前缀，一种不加(所谓的标准格式与省略格式)；
  • 在其他高级语言中如C++，静态初始化不能拆开写(即省略格式)，但Java标准格式可以；
  • 动态初始化数组时，内存中全部写0，即int为0、float为0.0、对象为null、char为\u0000； 
    // 动态初始化，在创建数组时指定数组长度
int[] array1 = new int[10];
System.out.println(array1);
int[] array2 = new int[10];
System.out.println(array2);

// 静态初始化，创建数组时直接以数据长度为准
int[] array3 = new int[] {1, 2, 3, 4};
System.out.println(array3);
int[] array4 = {1, 2, 3, 4};
System.out.println(array4);

// 初始化可以先定义变量再赋值，但有一种情况例外
int[] array5;
array5 = new int[10];
int[] array6;
array6 = new int[] {1, 2, 3, 4};
int[] array7;
array7 = {1, 2, 3, 4}; // 注意：这种情况是非法的，编译报错

2 相关总结

2.1 类与对象

[……]

继续阅读