三天回顾Java——零基础速成实战

第二天初识Java入门基础（下）

11.网络编程

11.1、概述11.2、**网络通信的要素**11.3、IP11.4、端口11.5、通信协议

11.5.1**TCP UDP 对比** 11.6、TCP

11.6.1文件上传11.6.2Tomcat 11.7、DUP

11.7.1发送接收消息11.7.2多线程发送接收消息 11.8、URL 12、注解和反射

12.1、注解概念12.2：内置注解

12.2.1、内置注解 12.3：什么是元注解

12.3.1、元注解 12.4：自定义注解

12.4.1、自定义注解 12.5：反射概述

12.5.1、反射概念 12.6：获取反射对象

12.6.1、反射机制提供的功能12.6.2、反射相关的主要API12.6.3、反射初体验12.7.1：得到Class类的几种方式 13、JUC详细学习

13.1、什么是JUC13.2、线程和进程

13.2.1**并发、并行**13.2.2线程有几个状态？13.2.3.**wait/sleep的区别** 13.3、Lock锁（重点）

13.3.1.Lock接口**13.3.2.Synchronized 和 Lock区别**13.2.3、生产者和消费者问题！13.2.4、八锁现象13.2.5小结 13.4、集合类不安全

13.4.1、List不安全13.4.2、Set不安全13.4.3、Map不安全 13.5、Callable(简单)13.6、常用的辅助类(必会！)

13.6.1 CountDownLatch13.6.2 CyclickBarrier13.6.3 Semaphore 13.7、读写锁13.8、阻塞队列

**13.8.1四组API** 13.9.SynchronousQueue同步队列13.10、线程池(重点)13.11、四大函数式接口（必需掌握）

13.11.1**函数式接口：**13.11.2、Stream流式计算13.11.3链式编程 ===13.11.4,lambda表达式 13.12、ForkJoin13.13、异步回调13.14.JMM13.15、Volatile

13.15.1.保证可见性13.15.2.**不保证原子性****13.15.3、禁止指令重排** 13.16、玩转单例模式

13.16.1.饿汉式、DCL懒汉式13.16.2枚举 13.17、深入理解CAS13.18、原子引用13.19、各种锁的理解

13.19.1、公平锁、非公平锁13.19.2、可重入锁13.19.3.lock锁13.19.4、自旋锁13.19.5.自我设计自旋锁：13.19.6死锁》》》完结撒花

第二天初识Java入门基础（下）

11.网络编程

InetAddress  	 获取地址
InetAddress.getCanonicalHostName		规范的名字
InetAddress.getHostAddress		IP
InetAddress.getHostName		域名或自己电脑的名字
InetSocketAddress		实现 IP 地址及端口
InetAddress				实现 IP 地址
ServerSocket				建立服务的端口
.accept						阻塞监听等待连接
Socket						创建连接
.getInputStream				获取IO输入流
.getOutputStream			获取IO输出流
ByteArrayOutputStream		byte类型数组管道输出流
FileOutputStream		文件字符输出流
FileInputStream			文件字符输入流
shutdownOutput			停止输出
DatagramSocket			数据包端口
DatagramPacket			数据包
.send			发送
.receive		阻塞接收
BufferedReader			缓存区读取
InputStreamReader		输入流读取
.readLine				读取的一行内容
URL			统一资源定位符
.openConnection				打开连接
HttpURLConnection			指定协议HTTP

11.1、概述

计算机网络

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

11.2、网络通信的要素

如何实现网络的通信？

通信双方地址：

ip端口号192.168.16，124：5900

规则：网络通信的协议

http, ftp, smtp, tcp,udp…

TCP/IP参考模型：

小结：

1.网络编程中有两个主要的问题

如何准确的定位到网络上的一台或者多台主机

找到主机之后如何进行通信

2.网络编程中的要素

IP 和端口号 IP网络通信协议 udp,tcp

3.万物皆对象

IP和网络通信协议都可以生成对象 11.3、IP

ip地址：InetAddress

唯一定位一台网络上计算机

127.0.0.1：本机Iocalhost

ip地址的分类

ipv4/ipv6

IPV4：127.0.01 ,4个字节组成，0~255，总共42亿；30亿都在北美，亚洲4亿，2011年就已经用尽IPV6：128位。8个无符号整数。2001:acca:0ac1:0002:0ab7:1153:2210:ccc1

公网（互联网）-私网（局域网）

ABCD类地址

192.168.xxx.xx 专门给组织内部使用

域名：记忆IP问题

IP：www.xxx.com 方便记录

InetAddress  	 获取地址
InetAddress.getCanonicalHostName		规范的名字
InetAddress.getHostAddress		IP
InetAddress.getHostName		域名或自己电脑的名字

11.4、端口

端口表示计算机上的一个程序的进程；

不同的进程有不同的端口！用来区分软件！

被规定0~65535，不能使用相同的端口

TCP，UDP：65535*2，tcp : 80, udp : 80 这样不影响。单个协议下，端口号不能冲突

端口分类

公有端口 0~1023 （尽量不用）

HTTP：80HTTPS：443FTP：21Telent：23 程序注册端口：1024~49151，分配用户或者程序

Tomcat：8080MySQL：3306Oracle：1521 动态、私有：49152~65535（尽量不用）

netstat -ano #查看所有的端口
netstat -ano|findstr "5900" #查看指定的端口
tasklist|findstr "8696" #查看指定端口的进程

找到电脑上特定端口，或有其对应的处理程序，才能收到发出的程序

InetSocketAddress		 IP 地址及端口
InetAddress				 IP 地址

11.5、通信协议

协议：约定，双方使用相同可识别的语言

**网络通信协议：**速率、传输码率、代码结构、传输控制… …

主要使用：**TCP/IP协议簇：**实际上是一组协议

主要：

TCP：用户传输协议 {类似于打电话，需要两边进行连接}UDP：用户数据报协议 {类似于发短信，不需要两边连接也可以发出，但不一定能送到}

出名的协议：

TCP：IP：网络互连协议 11.5.1TCP UDP 对比

TCP：打电话

连接、稳定三次握手四次挥手

最少需要三次，保证稳定连接
A——	我要连接 ——>B
B—— 你可以连接 ——>A
A—— 那我连接了 ——>B
连接成功！

四次挥手
A——我要断开——>B
B——你可以断开——>A

B——你确定断开？——>A
A——我确定断开！——>B
连接断开

客户端、服务端：主动和被动的过程传输完成，释放连接，效率低

不连接、不稳定客户端、服务端：没有明确的界限不管有没有准备好，都可以发给你DDOS：洪水攻击！（饱和攻击）

11.6、TCP

服务器

建立服务的端口 ServerSocket等待用户的连接 accept接收用户的信息 11.6.1文件上传

服务器端

    import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpClientDemo02 {
    public static void main(String[] args) throws IOException {
        //1.创建服务
        ServerSocket serverSocket = new ServerSocket(9000);
        //2.监听客户端的连接
        System.out.println("等待连接");
        Socket socket = serverSocket.accept();  //阻塞式监听，会一直等待客户端连接
        //3.获取输入流
        InputStream is = socket.getInputStream();
        //文件输出
        FileOutputStream fos = new FileOutputStream(new File("666.jpg"));
        byte[] buffer = new byte[1024];
        int len;
        while ((len=is.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }
        
        //服务器端接收完毕，并回复信息
        OutputStream os = socket.getOutputStream();
        os.write("我接收完毕，你可以断开".getBytes());
    //关闭资源
    os.close();
    fos.close();
    is.close();
    socket.close();
    serverSocket.close();

}}

客户端

   import java.io.*;
import java.net.InetAddress;
import java.net.Socket;

public class TcpServerDemo02 {
    public static void main(String[] args) throws Exception {
        //1.创建一个Socket连接
        // Socket（主机--端口号）
        //InetAddress.getByNam（主机--IP地址）
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9000);
        //2.创建一个输出流
        OutputStream os = socket.getOutputStream();
        //3.读取文件
        FileInputStream fis = new FileInputStream(new File("321.jpg"));
        //4.写出文件
        byte[] buffer = new byte[1024];
        int len;
        while((len = fis.read(buffer))!=-1){
            os.write(buffer,0,len);
        }
        
        //客户端已经传输完毕
        socket.shutdownOutput();
        //接收服务端完毕信息
        InputStream inputStream = socket.getInputStream();
        //由于收到的式String byte[]数组，使用byte输出管道流
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buffer2 = new byte[1024];
        int len2;
        while((len2 = inputStream.read(buffer))!=-1){
            baos.write(buffer,0,len2);
        }
        System.out.println(baos.toString());
   //关闭资源
    baos.close();
    inputStream.close();
    fis.close();
    os.close();
    socket.close();
}}

FileOutputStream		文件输出流
FileInputStream			文件输入流
shutdownOutput			停止输出

11.6.2Tomcat

服务端

自定义 STomcat 服务器 S ：Java 后台开发！

客户端

自定义 C浏览器 B 11.7、DUP

发短信：不用连接，只需要知道对方的地址！

11.7.1发送接收消息 11.7.2多线程发送接收消息

发送线程

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

public class TalkSend implements Runnable{
        DatagramSocket socket = null;
        BufferedReader reader = null;

        private int fromPort;
        private String toIP;
        private int toPort;


    public TalkSend(int fromPort, String toIP, int toPort) {
        this.fromPort = fromPort;
        this.toIP = toIP;
        this.toPort = toPort;
    
        try {
            socket = new DatagramSocket(fromPort);
        } catch (SocketException e) {
            e.printStackTrace();
        }


    }
    
    @Override
    public void run() {
    
        try {
            while(true){
                //准备数据：控制台读取 System.in
                BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
                //发包内数据
                String data = reader.readLine();
                byte[] datas = data.getBytes();
                DatagramPacket packet = new DatagramPacket(datas,0,datas.length,new InetSocketAddress(this.toIP,this.toPort));
                //发送包
                socket.send(packet);
    
                if (data.equals("bye")){
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    
        //关闭流
        socket.close();
    }

}

接收线程

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class TalkReceive implements Runnable{
    DatagramSocket socket =null;
    private int port;
    private String msgfrom;

    public TalkReceive(int port, String msgfrom) {
        this.port = port;
        this.msgfrom = msgfrom;
    
        try {
            socket = new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }
    
    @Override
    public void run() {
        try {
            while(true){
                //准备接收包裹
                byte[] container = new byte[1024];
                DatagramPacket packet = new DatagramPacket(container,0,container.length);
                //阻塞式接收
                socket.receive(packet);
                //断开连接
                //将接收包转换为 String 格式
                byte[] data = packet.getData();
                String receiveData = new String(data,0,data.length);
                System.out.println(msgfrom+":"+receiveData);
                if (receiveData.equals("bye")){
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        socket.close();
    }

}

学生线程

public class TalkStudent {
    public static void main(String[] args) {
        //学生同时开启两个线程
        //学生自己的发送端口、接收IP、接收端口
        new Thread(new TalkSend(6666,"localhost",9999)).start();
        //学生自己接收端口、发送过来者
        new Thread(new TalkReceive(8888,"老师")).start();
    }
}

教师线程

package com.ssxxz.chat;

public class TalkTeacher {
    public static void main(String[] args) {
        //老师
        //老师自己的发送端口、接收IP、接收端口
        new Thread(new TalkSend(7777,"localhost",8888)).start();
        //老师自己接收端口、发送过来者
        new Thread(new TalkReceive(9999,"学生")).start();
    }
}

11.8、URL

https://www.baidu.com/

统一资源定位符：定位资源的，定位互联网上的某一个资源

DNS 域名解析：www.baidu.com == xxx.x…x…x 的IP号

协议：（https） //ip地址：端口/项目名/资源

URL常用方法

public class DRLDemo01 {
    public static void main(String[] args) throws MalformedURLException {
        URL url = new URL("http://localhost:8080/helloworld/index.jsp?username=kuangshen&password==123");

        //协议http
        System.out.println(url.getProtocol());
        //主机ip,localhost
        System.out.println(url.getHost());
        //端口，8080
        System.out.println(url.getPort());
        //文件，/helloworld/index.jsp
        System.out.println(url.getPath());
        //全路径，/helloworld/index.jsp?username=kuangshen&password==123
        System.out.println(url.getFile());
        //参数，username=kuangshen&password==123
        System.out.println(url.getQuery());
    }

}

URL网络下载

public class UrlDown {
    public static void main(String[] args) throws Exception {
        //1.下载地址
        URL url = new URL("https:/**
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    
    group.add(this);

    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            
        }
    }
}
**这是一个C++底层，Java是没有权限操作底层硬件的**
private native void start0();

Java是没有权限去开启线程、操作硬件的，这是一个native的一个本地方法，它调用的底层的C++代码。

13.2.1并发、并行

并发：多线程操作同一个资源。

CPU 只有一核，模拟出来多条线程，天下武功，唯快不破。那么我们就可以使用CPU快速交替，来模拟多线程。

并行：多个人一起行走

CPU多核，多个线程可以同时执行。我们可以使用线程池！

public class Test1 {
    public static void main(String[] args) {
        //获取cpu的核数
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

并发编程的本质：充分利用CPU的资源！ 13.2.2线程有几个状态？

线程的状态：6个状态

   public enum State {
        
    	//运行
        NEW,
   
	//运行
    RUNNABLE,

    
	//阻塞
    BLOCKED,

    
	//等待
    WAITING,

    
	//超时等待
    TIMED_WAITING,

    
	//终止
    TERMINATED;
}

13.2.3.wait/sleep的区别

来自不同的类

wait => Object类

sleep => Thread类

一般情况企业中使用休眠是：

TimeUnit.DAYS.sleep(1); //休眠1天
TimeUnit.SECONDS.sleep(1); //休眠1s

关于锁的释放

wait 会释放锁；

sleep睡觉了，不会释放锁；

使用的范围是不同的

wait 必须在同步代码块中；

sleep 可以在任何地方睡；

是否需要捕获异常

wait是不需要捕获异常；

sleep必须要捕获异常；

13.3、Lock锁（重点）

传统的Synchronized

   public class SaleTicketDemo01 {
   public static void main(String[] args) {
       //多线程操作
       //并发：多线程操作同一个资源类，把资源类丢入线程
       Ticket ticket = new Ticket();
new Thread(()->{
    for(int i=0;i<40;i++){
        ticket.sale();
    }
},"A").start();
new Thread(()->{
    for(int i=0;i<40;i++){
        ticket.sale();
    }
},"B").start();
new Thread(()->{
    for(int i=0;i<40;i++){
        ticket.sale();
    }
},"C").start();
}
}
//资源类
//属性+方法
//oop
class Ticket{
private int number=50;


    //卖票的方式
    // synchronized 本质：队列，锁
    public synchronized void sale(){
        if(number>0){
            System.out.println(Thread.currentThread().getName()+" 卖出了第"+number+" 张票,剩余："+number+" 张票");
            number--;
        }
    }

13.3.1.Lock接口

公平锁：十分公平，必须先来后到~；

非公平锁：十分不公平，可以插队；(默认为非公平锁)

public class SaleTicketDemo02 {
    public static void main(String[] args) {
        //多线程操作
        //并发：多线程操作同一个资源类，把资源类丢入线程
        Ticket2 ticket = new Ticket2();
        new Thread(()->{for(int i=0;i<40;i++) ticket.sale(); },"A").start();
        new Thread(()->{for(int i=0;i<40;i++) ticket.sale(); },"B").start();
        new Thread(()->{for(int i=0;i<40;i++) ticket.sale(); },"C").start();
    }
}

//lock三部曲
//1、    Lock lock=new ReentrantLock();
//2、    lock.lock() 加锁
//3、    finally=> 解锁：lock.unlock();
class Ticket2{
    private int number=50;
Lock lock=new ReentrantLock();

//卖票的方式
// 使用Lock 锁
public void sale(){
    //加锁
    lock.lock();
    try {
        //业务代码
        if(number>=0){
            System.out.println(Thread.currentThread().getName()+" 卖出了第"+number+" 张票,剩余："+number+" 张票");
            number--;
        }
    }catch (Exception e) {
        e.printStackTrace();
    }
    finally {
        //解锁
        lock.unlock();
    }
}
}

13.3.2.Synchronized 和 Lock区别

Synchronized 内置的Java关键字，Lock是一个Java类

Synchronized 无法判断获取锁的状态，Lock可以判断

Synchronized 会自动释放锁，lock必须要手动加锁和手动释放锁！可能会遇到死锁

Synchronized 线程1(获得锁->阻塞)、线程2(等待)；

lock就不一定会一直等待下去，lock会有一个trylock去尝试获取锁，不会造成长久的等待。

Synchronized 是可重入锁，不可以中断的，非公平的；Lock，可重入的，可以判断锁，可以自己设置公平锁和非公平锁；

Synchronized 适合锁少量的代码同步问题，Lock适合锁大量的同步代码；

13.2.3、生产者和消费者问题！

我们这次使用lock版本

Synchronized版本wait notify可以实现，该方法是传统版本；

  public class A {
    public static void main(String[] args) {
        Data data = new Data();
  new Thread(()->{for(int i=0;i<10;i++) {
        try {
            data.increment();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    },"A").start();
    new Thread(()->{for(int i=0;i<10;i++) {
        try {
            data.decrement();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }},"B").start();
}
}
class Data{
    //数字  资源类
    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        if(number!=0){
            //等待操作
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程 我+1完毕了
        this.notifyAll();
    }
    
    //-1
    public synchronized void decrement() throws InterruptedException {
        if(number==0){
            //等待操作
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程  我-1完毕了
        this.notifyAll();
    }

}
//问题存在，A线程B线程，现在如果我有四个线程A B C D！

//解决方案： if 改为while即可，防止虚假唤醒

//这样就不存在问题了：

JUC版本的生产者和消费者问题

await、signal 替换 wait、notify

通过Lock找到Condition

   public class B {
    public static void main(String[] args) {
        Data2 data = new Data2();
   new Thread(()->{for(int i=0;i<10;i++) {
        data.increment();
    }
    },"A").start();
    new Thread(()->{for(int i=0;i<10;i++) {
        data.decrement();
    }},"B").start();
    new Thread(()->{for(int i=0;i<10;i++) {
        data.increment();
    }
    },"C").start();
    new Thread(()->{for(int i=0;i<10;i++) {
        data.decrement();
    }
    },"D").start();
}
}
class Data2{
    //数字  资源类
    private int number = 0;

    //lock锁
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    
    //+1
    public void increment()  {
        lock.lock();
        try{
    
            //业务
            while (number!=0){
                //等待操作
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //通知其他线程 我+1完毕了
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    
    //-1
    public void decrement()  {
        lock.lock();
        try{
            //业务
            while (number==0){
                //等待操作
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //通知其他线程 我+1完毕了
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

Condition的优势：精准的通知和唤醒的线程！

如果我们要指定通知的下一个进行顺序怎么办呢？我们可以使用Condition来指定通知进程~


public class C {

    public static void main(String[] args) {
        Data3 data3 = new Data3();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data3.printA();
            }
        },"A").start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data3.printB();
            }
        },"B").start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data3.printC();
            }
        },"C").start();
    }

}

class Data3{
    //资源类
    private Lock lock=new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int number = 1; //1A 2B 3C

    public void printA(){
        lock.lock();
        try {
            //业务 判断 -> 执行 -> 通知
            while(number!=1){
                //等待
                condition1.await();
            }
            //操作
            System.out.println(Thread.currentThread().getName()+",AAAAA");
            //唤醒指定的线程
            number=2;
            condition2.signal(); // 唤醒2
    
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printB(){
        lock.lock();
        try {
            //业务 判断 -> 执行 -> 通知
            while (number!=2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+",BBBBB");
            //唤醒3
            number=3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try {
            //业务 判断 -> 执行 -> 通知
            while(number!=3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+",CCCCC");
            //唤醒1
            number=1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    }

13.2.4、八锁现象

即为8个常见的锁现象

锁会锁住：对象、Class

深刻理解我们的锁

问题1：

结果是：先发短信，如何再打电话！

为什么？如果你认为是顺序在前？这个答案是错误的！

问题2：
我们再来看：我们让发短信延迟4s

现在结果是什么呢？

结果：还是先发短信，然后再打电话！

why？

原因：并不是顺序执行！是因为synchronized 锁的对象是方法的调用！对于两个方法用的是同一个锁，谁先拿到谁先执行！另外一个则等待！
问题3：
如果我们添加一个普通方法，那么先执行哪一个呢？

答案是：先执行hello，然后再执行发短信！原因是hello是一个普通方法，不受synchronized锁的影响，但是我发现，如果我把发短信里面的延迟4秒去掉，那么就会顺序执行，先执行发短信然后再执行hello，原因应该是顺序执行的原因吧,不是太理解。

问题4：
如果我们使用的是两个对象，一个调用发短信，一个调用打电话，那么整个顺序是怎么样的呢？

答案是：先打电话，后发短信。原因：在发短信方法中延迟了4s，又因为synchronized锁的是对象，但是我们这使用的是两个对象，所以每个对象都有一把锁，所以不会造成锁的等待。正常执行

问题5，6：
如果我们把synchronized的方法加上static变成静态方法！那么顺序又是怎么样的呢？

（1）我们先来使用一个对象调用两个方法！

答案是：先发短信,后打电话

（2）如果我们使用两个对象调用两个方法！

答案是：还是先发短信，后打电话

原因是什么呢？为什么加了static就始终前面一个对象先执行呢！为什么后面会等待呢？

原因是：对于static静态方法来说，对于整个类Class来说只有一份，对于不同的对象使用的是同一份方法，相当于这个方法是属于这个类的，如果静态static方法使用synchronized锁定，那么这个synchronized锁会锁住整个对象！不管多少个对象，对于静态的锁都只有一把锁，谁先拿到这个锁就先执行，其他的进程都需要等待！

问题7：
如果我们使用一个静态同步方法、一个同步方法、一个对象调用顺序是什么？

明显答案是：先打电话，后发短信了。

因为一个锁的是Class类模板，一个锁的是对象调用者。后面那个打电话不需要等待发短信，直接运行就可以了。

问题8：
如果我们使用一个静态同步方法、一个同步方法、两个对象调用顺序是什么呢？

当然答案是：先打电话、后发短信！

因为两个对象，一样的原因：两把锁锁的不是同一个东西，所以后面的第二个对象不需要等待第一个对象的执行。

13.2.5小结

new 出来的 this 是具体的一个对象

static Class 是唯一的一个模板

13.4、集合类不安全 13.4.1、List不安全

我们来看一下List这个集合类：

//java.util.ConcurrentModificationException 并发修改异常！
public class ListTest {
    public static void main(String[] args) {

        List

三天回顾Java——零基础速成实战

Java相关栏目本月热门文章