知识梳理：线程并发问题&线程安全&线程同步&基于TCP/IP的Socket通信&JSON数据格式&注解
目录：线程并发问题&线程安全&线程同步&基于TCP/IP的Socket通信&JSON数据格式&注解
线程并发问题(线程安全)
线程安全
多线程并发时，多个线程同时操作同一个内存区域(变量)，可能会导致的结果不一致的问题；所谓线程安全，指的是在多线程并发操作的时候能保证共享的变量数据一致
并发编程三要素
线程并发时需要保证线程安全，需要满足三大条件:
- 原子性
- 可见性
- 有序性
原子性（Atomicity)
对于一条线程执行来说要保证，要么都成功，要么都失败；对于原子性操作可以通过加锁的方式实现；Synchronized和ReentrantLock保证线程的原子性
可见性（Visibility）
多条线程操作同一个变量时，需要保证其中一条线程对变量的修改，对其他线程也是可见的
有序性（Ordering)
对于每一条线程的执行，内部应该是有序的：
- 代码顺序执行
- 锁的释放应该在获得之后
- 变量读取操作，在修改操作之后
线程同步解决方案
Synchronized
synchronized的关键字使用包含三种方式:
- synchronized块：对象锁
- synchronized方法：在方法声明的时候使用
- 类锁：在静态方法或者同步块中使用类的Class对象
被synchronized鎖住的区域称之为临界区
死锁
由于线程并发，会出现共享变量的情况，如果使用同步锁，对象会被锁住，如果存在多个线程争抢资源时陷入僵局(多个线程在等待被对方线程占有的资源释放时陷入的无限等待状态)，这种情况称之为死锁。死锁无法解决，只能尽量避免
public class DeathLock implements Runnable{
/**
* 使用静态修饰的原因是希望意向两个对象永远只存在一个实例（不论有多少Runnable对象）
*/
private static Object obj1 = new Object();
private static Object obj2 = new Object();
private int flag;
public DeathLock(int flag) {
this.flag = flag;
}
@Override
public void run() {
if(flag == 1) {
synchronized (obj1) {
System.out.println("线程1锁住了obj1");
synchronized (obj2) {
System.out.println("线程1锁住了obj2,结束。。。。");
}
}
}else if(flag == 2){
synchronized (obj2) {
System.out.println("线程2锁住了obj2");
synchronized (obj1) {
System.out.println("线程2锁住了obj1,结束。。。。");
}
}
}
}
public static void main(String[] args) {
DeathLock d1 = new DeathLock(1);
DeathLock d2 = new DeathLock(2);
new Thread(d1).start();
new Thread(d2).start();
}
}
Lock
提供了跟synchronized相同的功能，也可以对于的对象实现加锁，ReentrantLock粒度控制方面比synchronized更细，同时支持公平锁和非公平锁（默认）,synchronized只支持非公平锁
注意事项:
- 锁的获取位置一般在try语句块之前
- 锁的释放一般放到finally语句块中
ReentrantLock和Synchronized的区别：
- ReentrantLock是一个实现类，后者是一个关键字
- ReentracntLock需要手动获取锁以及释放锁（粒度控制更细）；后者自动加锁，临界区(synchronized锁住的区域)的代码执行完之后自动释放
- ReentrantLock支持公平锁以及非公平锁；sychronized只支持非公平锁
- synchronized一般用于少量代码同步，ReentrantLock一般用于大量的同步代码块
volatile
在前面的线程并发中，对于原子性的解决方案使用synchronized或lock实现同步；但是对于数据的可见性来说，我们还需要另外处理，关于可见性，实时的将全局变量的更新立即同步给其他线程。
Wait¬ify
线程运行时若需要限时等待，则可以通过sleep()方法设置休眠时间，但是对于一些不定时的等待需求sleep则无法实现；对于这种需求，java.lang.Object类中提供了用于实现等待和唤醒的方法：wait和notify；
- wait()
- notify()
在使用wait和notify的时候一定要求确保当前线程持有对象的监视器(对象锁)
wait()和sleep()区别？
- sleep是来自Thread类中的一个方法；wait是属于Object类的方法
- sleep是限时等待，在等待的时限到达时自动恢复；而wait是无限等待，必须要等到其他线程调用该对象上的notify方法（或notifyAll）才能继续执行
- sleep使用时不需要持有对象锁，而wait使用时必须确保当前线程持有该对象的对象锁，否则会有异常(java.lang.IllegalMonitorStateException)
网络协议
网络协议就是计算器网络设备相互之间通信的标准（暗号），在互联网标准组织的推动下，将网络协议分为两种：
- TCP/IP : 传输控制协议/ip协议
- UDP：用户数据报协议
TCP/IP协议（打电话）
传输控制协议，是一个安全可靠的互联网协议，需要通信的主机之间需要先建立正确的链接，才能够进行通信，并且改协议能够保证数据传输稳定性(必须的保证信息发送到一台主机，由该主机确认之后才能发送下一条信息)，另外该协议也能保证数据传输的有序性(先发送的信息一定先到达)。一般基于C/S架构，存在服务器客户端模式。
应用领域: 远程登录
UDP协议（发快递）
User Diagram Protocol（用户数据报协议），是一个不安全的网络协议，不需要双方之间建立联系，也不保证信息传输的有序性(有可能后发消息先到)，传输效率比TCP/IP更高.没有专门服务器和客户端，只有发送端和接收端
应用领域: 广播，视频会议
InetAddress类
IndetAddress是位于java.net包中提供的用于表示ip地址和主机的类，常用方法：
- getLocalhost() 获取本地主机
- getByName() 根据提供的主机名或者ip获取InetAddress对象
- getHostAddress() 获取主机地址
- getHostName() 获取主机名称
基于TCP/IP的Socket通信
Socket（套接字）,实际上就是由IP地址跟端口号的结合，通过Socket对象可以实现两台主机之间的通信；Socket分为服务端Socket(java.net.ServerSocket)，以及客户端Socket(java.net.Socket)
综合案例：基于TCP/IP的文件服务器实现
服务端
/**
* 服务器
* @author mrchai
*
*/
public class FileServer {
public static void main(String[] args) throws IOException {
//准备需要传输的文件对象
File target = new File("D:\\集团资料\\宣讲\\video\\云计算&大数据\\2017云栖.mp4");
try(
//创建并开启文件服务
ServerSocket ss = new ServerSocket(6789);
Socket s = ss.accept();
//创建文件的输入流并包装为缓冲流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(target));
//获取基于Socket的输出流
BufferedOutputStream bos = new BufferedOutputStream(s.getOutputStream());
){
System.out.println("客户端连接:"+s.getInetAddress().getHostAddress());
System.out.println("开始传输....");
//每次读取的字节内容
int b = 0;
while((b = bis.read()) != -1) {
bos.write(b);
}
System.out.println("传输完成");
}catch (Exception e) {
e.printStackTrace();
}
}
}
客戶端
/**
* 客户端
* @author mrchai
*
*/
public class FileClient {
public static void main(String[] args) throws UnknownHostException, IOException {
File f = new File("C:\\Users\\Administrator\\Desktop\\a.mp4");
try(
//连接指定ip指定端口服务
Socket s = new Socket("192.168.7.141",6666);
//获取基于Socket的输入流并包装为缓冲流
BufferedInputStream bis = new BufferedInputStream(s.getInputStream());
//获取目标文件的输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(f));
){
System.out.println("开始接收...");
int b = 0;
while((b = bis.read()) != -1) {
bos.write(b);
}
System.out.println("接收完成!");
}catch (Exception e) {
e.printStackTrace();
}
}
}
HttpURLConnection
HttpURLConnection用于获取一个http连接，是一个http客户端工具类，HttpURLConnection从URLConnection继承而来，通过该类可以读取服务端响应的数据（文本，视频，音频，图片等资源）。
封装通用HttpUtils工具
对于大多数请求，主要是获取服务端文本数据，因此封装以下工具类用户获取网络资源:
/**
* HTTP工具类，可以通过该工具类轻松访问在线API地址
* 并获取响应的数据
* @author mrchai
*/
public class HttpUtils {
static class CallRemoteData implements Callable<String>{
private String url;
public CallRemoteData(String url) {
this.url = url;
}
@Override
public String call() throws Exception {
//根据提供的url地址构建一个URL对象
URL urlConn = new URL(url);
//打开连接
HttpURLConnection conn = (HttpURLConnection)urlConn.openConnection();
//设置请求方式
conn.setRequestMethod("GET");
//获取响应的状态码
int code = conn.getResponseCode();
if(code == HttpURLConnection.HTTP_NOT_FOUND) {
throw new Exception("请求的资源不存在!");
}
if(code == HttpURLConnection.HTTP_INTERNAL_ERROR) {
throw new Exception("服务器内部错误");
}
if(code != HttpURLConnection.HTTP_OK) {
throw new Exception("未知错误!");
}
BufferedReader br = null;
try {
//获取连接的输入流
InputStream is = conn.getInputStream();
InputStreamReader isr = new InputStreamReader(is,"utf-8");
br = new BufferedReader(isr);
//创建一个可变长字符串
StringBuffer sbf = new StringBuffer();
String str = "";
while((str = br.readLine()) != null) {
sbf.append(str).append("\r\n");
}
return sbf.toString();
}finally{
if(br != null)br.close();
//断开连接
conn.disconnect();
}
}
}
/**
* 根据提供的url地址字符串获取服务端响应回来的字符串数据
* @param url
* @return
*/
public static String getData(String url) {
try {
//创建Callable对象
Callable<String> call = new CallRemoteData(url);
FutureTask<String> task = new FutureTask<>(call); //Runnable
//创建并启动线程
new Thread(task).start();
//获取执行结果并返回
return task.get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
return null;
}
public static void main(String[] args) {
String url = "http://music.softeem.top/list";
String json = HttpUtils.getData(url);
System.out.println(json);
}
}
JSON数据格式
JSON（JavaScript Object Notation）是一种与语言平台无关的数据交换格式，有着比XML更为轻量级的数据表现形式，是目前大多数互联网应用程序之间的数据交换格式的首选。
FastJSON使用
fastJSON是由阿里巴巴开源的JSON库，号称全世界最快的json插件，常用方法：
- toJSONString(Object) 将一个Java对象转换为Json字符串
- parseObject(String json,Class
clazz) 将一个json字符串转换为Java对象 - parseArray(String json,Class
clazz) 将一个json字符串转换为Java集合
public static void main(String[] args) {
User u = new User();
u.setId(10);
u.setUsername("softeem");
u.setPassword("123456");
u.setVip(true);
//1.将Java对象转换为json字符串
String json =JSON.toJSONString(u);
System.out.println(json);
//2.将json字符串转化为Java对象
json = "{\"id\":20,\"password\":\"666\",\"username\":\"admin\",\"vip\":false}";
u = JSON.parseObject(json, User.class);
System.out.println(u);
//3.如何将集合转换为json字符串
List<User> list = new ArrayList<>();
list.add(new User(1, "softeem", "123456", true));
list.add(new User(2, "james", "000123", false));
list.add(new User(3, "kobe", "888123", false));
list.add(new User(4, "面筋哥", "666123", true));
json = JSON.toJSONString(list);
System.out.println(json);
//4.如何将一个json数组转换为一个Java集合
list = JSON.parseArray(json,User.class);
System.out.println(list);
//5.若解析的json字符串找不到对应的Java类时？
String json2 = "{\"sid\":10,\"name\":\"孙悟空\"}";
//将json字符串解析为Java对象;JSONObject实际上就是一个Map集合
JSONObject obj = JSON.parseObject(json2);
int sid = obj.getInteger("sid");
String name = obj.getString("name");
System.out.println(sid+"---"+name);
}
注解概述
注解(Annotation)，是jdk5之后新增一项技术，可以通过在Java类，方法，属性等元素上加上注解，实现一些特定功能：编译检查，丰富文档化注释的内容，实现项目特定程序配置。注解只需要少量代码的存在即可;注释即解释；注解通常不会影响程序的正常逻辑，只是一种标记，Java中的注解通常是给编译器进行识别的
内置注解
jdk中包含一些内置的注解类型：
- @Override：检查方法是否属于重写
- @Depracted : 标记类，属性，方法为过时
- @SupressWarning：抑制编译抛出的警告信息
- @FunctionalInterface：java8新增函数式接口的检查注解
自定义注解
java中除了包含一些内置注解以外，还允许开发者自定义注解来解决程序配置问题，如果需要使用自定义注解，只需要使用@interface创建即可：
public @interface MyAnno { }