锁的概念：

多个线程在对同一个资源进行访问时要上锁

synchronized加在静态方法上和在代码中sychronized这个类是等价的：
加在非静态方法上和在代码中sychronized(this)是等价的
synchronized static void m() == sychronized (T.class) // 类锁
synchronized void m() == sychronized(this) // 对象锁

重点：
1、程序之中如果出现异常，默认情况下锁会被释放
底层源码有两个monitorexit,一个是锁正常情况下的退出，一个是异常情况下的退出

2、synchronized锁作用的是对象不是代码

synchronized锁升级的概念：
当只有一个线程访问时，在synchronized的对象（object）的markword上记录这个线程的ID,此时单个线程调用并没有加锁；如果有其他线程争用时会升级为轻量级锁，也叫自选锁，线程在那转圈访问锁是否被释放了，如果默认旋转一定时间（10次）还没有释放的话，锁就会升级为重量级锁，重量级锁时这个线程就会有一个队列，就会将这些线程放到等待队列中，等锁释放后根据队列中的顺序一次获得资源执行。

注：
加锁代码执行时间短，线程数少，用轻量级锁
执行时间长，线程数多，用重量级锁

synchronized(object)，object不要用基础类型的，如String,Integer,Long等：

原因是java的自动封箱和拆箱在作怪，Integer,Long：当执行i++，实际上就是i=new Integer(i+1)，所以执行完i++后i已经不是以前的那个对象了，同步块自然也就失效了
String: String定义的变量会放在常量池中，如果多个线程定义的String变量的值相等， 指向的地址是一致的，这样两个线程指向的实际就是同一个对象，这时锁就无效了。所以严格意义上来讲是不要用String常量来作为锁对象，但为了规避风险，最好直接就不要用
String作为锁对象
注：所以锁对象不要用基础的数据类型!!!

例子：如果有两以上的线程同时访问同一个共享资源，可能造成线程冲突，线程冲突会造成数据丢失、重复等严重问题。
以下通过两个线程同时访问同一个类，来表现线程冲突，如果产生冲突便会打印输出。

public class TestDemo {

	String name;
	
	public static void main(String[] args) {
		TestDemo td =new TestDemo();
		Thread t = new Thread() {
	    	@Override
	    	public void run() {
	    		try {
	    			while(true) {
	    				Thread.sleep(500);
	    				td.aa("ls");
	    			}
	    		}catch (InterruptedException e) {
					e.printStackTrace();
				}
	    	}
	    };
	    
	    t.start();

	    Thread f = new Thread() {
	    	public void run() {
                try {
                    while(true) {
                    Thread.sleep(500);
                    td.aa("aas");
                    }
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            
        };
        f.start();
	}
	
	public void aa(String name) {
		this.name=name;
		eq(name);
	}

	private void eq(String name) {
		if(!(name==this.name)) {
			System.out.println(this.name+" "+name);
		}
		
	}

}

日志打印：

ls aas

aas ls

aas ls

aas ls

ls aas

aas ls

aas ls

解决方法：可以使用synchronized关键字让线程同步。

线程的冲突：
在多个线程访问同一个对象的同一个属性时，才会出现线程冲突，线程冲突会造成数据丢失、重复等严重问题。为了避免这个问题可以加synchronized关键字让线程同步。
例子：

public class Test {
   String name;
   public static void main(String[] args) {
       final Test ts=new Test();
       final Test ts2=new Test();
       final Thread t=new Thread(){
           @Override
           public  void run(){
               while (true){
                   try {
                       ts.setName("张三");
                       Thread.sleep(1000);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
           }
       };
       t.start();
       final Thread t2=new Thread(){
           @Override
           public  void run(){
               while (true){
                   try {
                       ts2.setName("李四");
                       Thread.sleep(1000);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
           }
       };
       t2.start();
   }
  /*   1，放在函数中锁住整个函数，只有前一个线程执行完下一个函数才能访问   
   *    2，放在代码块中，锁住需要共享的资源，推荐使用   
   */
   public /*synchronized*/  void setName(String name){// 放在函数中锁住整个函数,只有前一个线程执行完下一个函数才能访问 

      // synchronized(this) {//2，放在代码块中，锁住需要共享的资源，推荐使用 
           this.name = name;
           eqName(name);
      // }
   }
   public void eqName(String name){
       if(name!=this.name)
           System.out.println(name+" "+this.name);
   }
}

本次作为一个刚入门的·程序员第一次给大家分享一些学习干货，以后会持续更新…
案例
使用多线程实现多个用户访问服务器端，服务器显示用户登录信息并提示用户登录成功·
服务器代码如下：
接下来是自定义的ThreadLogin类，实现了Runnable接口

User类(注意-要实现Serializable接口，不然无法实现序列化）：

客户端1：

客户端2，3只需要把User传的有参构造改下方法就可以啦^^
最后，奉上运行结果图：（小提示：先启动服务器，再启动客户端）
server运行结果图：

客户端：

希望能帮到有需要的小伙伴！！！

目录

前言回顾

一、多用户服务器

二、使用线程池实现服务端多线程

1、单线程版本

2、多线程版本

三、多用户与服务端通信演示

四、多用户服务器完整代码

最后

前言回顾

在上一篇《Java多线程实现TCP网络Socket编程(C/S通信)》，我们解决了服务器端在建立连接后，连续发送多条信息给客户端接收的问题，解决办法容易理解，将客户端接收信息的功能集中给线程处理，实现多线程同步进行。

同理，上一篇结束语留下来一个问题，简而言之，相当于多用户访问服务器资源，服务器应该与各个客户端建立连接，并进行通信对话，就像我们日常使用QQ、微信、视频等客户端，就是多用户与服务器通信的例子。

而上一篇中服务端只实现了单用户的功能，本篇将解决这个问题，详细记录服务端多线程的实现，目标是多用户（客户端）能够同时与服务器建立连接并通信，避免阻塞，进一步完善TCP的Socket网络通信，运用Java多线程技术，实现多用户与服务端Socket通信！

Java实现socket通信网络编程系列文章：

1. 基于UDP协议网络Socket编程(java实现C/S通信案例)【https://blog.csdn.net/Charzous/article/details/109016215】
2. 基于TCP协议网络socket编程(java实现C/S通信)【https://blog.csdn.net/Charzous/article/details/109016215】
3. Java多线程实现TCP网络Socket编程(C/S通信)【https://blog.csdn.net/Charzous/article/details/109283697】

一、多用户服务器

多用户服务器是指服务器能同时支持多个用户并发访问服务器所提供的服务资源,如聊天服务、文件传输等。

上一篇的TCPServer是单用户版本，每次只能和一个用户对话。我们可以尝试多用户连接，开启多个客户端，具体操作如下：

这样就允许同时并行执行多个客户端，测试发现，单用户版本的TCPServer.java程序能同时支持多个用户并发连接（TCP三次握手），但不能同时服务多用户对话，只有前一个用户退出后，后面的用户才能完成服务器连接。

多线程技术，线程调用的并行执行。

上一篇提到在java中有两种实现多线程的方法，一是使用Thread类，二是使用Runnable类并实现run()方法。下面将使用Runnable类对服务端相关操作功能进行封装，结合上一篇，就学到了两种多线程实现方法。

//使用Runnable类，作为匿名内部类
class Handler implements Runnable {
    public void run() {
   //实现run方法
    }
}

服务器面临很多客户的并发连接，这种情况的多线程方案一般是：

1. 主线程只负责监听客户请求和接受连接请求，用一个线程专门负责和一个客户对话，即一个客户请求成功后，创建一个新线程来专门负责该客户。对于这种方案，可以用上一篇方式new Thread创建线程，但是频繁创建线程需要消耗大量系统资源。所以不采用这种方法。
2. 对于服务器，一般使用线程池来管理和复用线程。线程池内部维护了若干个线程，没有任务的时候，这些线程都处于等待状态。如果有新任务，就分配一个空闲线程执行。如果所有线程都处于忙碌状态，新任务要么放入队列等待，要么增加一个新线程进行处理。

显然，我们采用第2种线程池的方法。 常见创建方法如下：

ExecutorService executorService = Executors.newFixedThreadPool(n);//指定线程数量
ExecutorService executorService = Executors.newCachedThreadPool();//动态线程池

接下来就是选择线程池的类型了。 使用第一个固定线程数的线程池，显然不够灵活，第二种方式的线程池会根据任务数量动态调整线程池的大小，作为小并发使用问题不大，但其在实际生产环境使用并不合适，如果并发量过大，常常会引发超出内存错误（OutOfMemoryError），根据我们的应用场景，可以用这个动态调整线程池。

二、使用线程池实现服务端多线程

1、单线程版本

首先，与之前的单线程通信对比一下，下面代码只能实现单用户与服务端通信，如果多用户与服务器通信，则出现阻塞。

    //单客户版本，每次只能与一个用户建立通信连接
    public void Service(){
        while (true){
            Socket socket=null;
            try {
                //此处程序阻塞，监听并等待用户发起连接，有连接请求就生成一个套接字
                socket=serverSocket.accept();

                //本地服务器控制台显示客户连接的用户信息
                System.out.println("New connection accepted:"+socket.getInetAddress());
                BufferedReader br=getReader(socket);//字符串输入流
                PrintWriter pw=getWriter(socket);//字符串输出流
                pw.println("来自服务器消息：欢迎使用本服务！");

                String msg=null;
                //此处程序阻塞，每次从输入流中读入一行字符串
                while ((msg=br.readLine())!=null){
                    //如果用户发送信息为”bye“，就结束通信
                    if(msg.equals("bye")){
                        pw.println("来自服务器消息：服务器断开连接，结束服务！");
                        System.out.println("客户端离开。");
                        break;
                    }
                    msg=msg.replace("?","!").replace("？","!")
                            .replace("吗","").replace("吗？","").replace("在","没");
                    pw.println("来自服务器消息："+msg);
                    pw.println("来自服务器,重复消息："+msg);
                }
            }catch (IOException e){
                e.printStackTrace();
            }finally {
                try {
                    if (socket!=null)
                        socket.close();//关闭socket连接以及相关的输入输出流
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

 所以，根据上面的分析，将该单线程版本服务端与客户端通信对话的功能独立处理，由一个线程来处理。这样就不会阻塞主进程的执行。具体实现如下面。

 2、多线程版本

1、创建匿名内部类Handler，实现Runnable类的run方法，将通信对话放到run()里面：

    class Handler implements Runnable {
        private Socket socket;

        public Handler(Socket socket) {
            this.socket = socket;
        }

        public void run() {
            //本地服务器控制台显示客户端连接的用户信息
            System.out.println("New connection accept:" + socket.getInetAddress());
            try {
                BufferedReader br = getReader(socket);
                PrintWriter pw = getWriter(socket);

                pw.println("From 服务器：欢迎使用服务！");

                String msg = null;
                while ((msg = br.readLine()) != null) {
                    if (msg.trim().equalsIgnoreCase("bye")) {
                        pw.println("From 服务器：服务器已断开连接，结束服务！");

                        System.out.println("客户端离开。");
                        break;
                    }
                    pw.println("From 服务器：" + msg);
                    pw.println("来自服务器,重复消息："+msg);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (socket != null)
                        socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

 2、使用newCachedThreadPool( )动态创建线程池

线程池作为成员变量：

    //创建动态线程池，适合小并发量，容易出现OutOfMemoryError
    private ExecutorService executorService=Executors.newCachedThreadPool();

 服务端的Service方法中创建新线程，交给线程池处理。

    //多客户版本，可以同时与多用户建立通信连接
    public void Service() throws IOException {
        while (true){
            Socket socket=null;
                socket=serverSocket.accept();
                //将服务器和客户端的通信交给线程池处理
                Handler handler=new Handler(socket);
                executorService.execute(handler);
            }
    }

三、多用户与服务端通信演示

之前服务端只支持单用户通信对话时候，新用户发送的信息阻塞，服务器无法返回。

很有趣发现一点，另外一端结束通信，与此同时，另一端则立即收到服务器的回复信息。

从显示的时间上初步观察，可以判断之前发送的信息是阻塞在服务端进程，断开一方连接后，服务端才将阻塞队列的信息发送到客户端。那使用多线程之后，结果是怎么样呢？

动图演示进一步体会：

四、多用户服务器完整代码

/*
 * TCPThreadServer.java
 * Copyright (c) 2020-11-02
 * author : Charzous
 * All right reserved.
 */

package chapter05;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TCPThreadServer {
    private int port =8008;//服务器监听窗口
    private ServerSocket serverSocket;//定义服务器套接字
    //创建动态线程池，适合小并发量，容易出现OutOfMemoryError
    private ExecutorService executorService=Executors.newCachedThreadPool();

    public TCPThreadServer() throws IOException{
        serverSocket =new ServerSocket(8008);
        System.out.println("服务器启动监听在"+port+"端口...");

    }

    private PrintWriter getWriter(Socket socket) throws IOException{
        //获得输出流缓冲区的地址
        OutputStream socketOut=socket.getOutputStream();
        //网络流写出需要使用flush，这里在printWriter构造方法直接设置为自动flush
        return new PrintWriter(new OutputStreamWriter(socketOut,"utf-8"),true);
    }

    private BufferedReader getReader(Socket socket) throws IOException{
        //获得输入流缓冲区的地址
        InputStream socketIn=socket.getInputStream();
        return new BufferedReader(new InputStreamReader(socketIn,"utf-8"));
    }

    //多客户版本，可以同时与多用户建立通信连接
    public void Service() throws IOException {
        while (true){
            Socket socket=null;
                socket=serverSocket.accept();
                //将服务器和客户端的通信交给线程池处理
                Handler handler=new Handler(socket);
                executorService.execute(handler);
            }
    }


    class Handler implements Runnable {
        private Socket socket;

        public Handler(Socket socket) {
            this.socket = socket;
        }

        public void run() {
            //本地服务器控制台显示客户端连接的用户信息
            System.out.println("New connection accept:" + socket.getInetAddress());
            try {
                BufferedReader br = getReader(socket);
                PrintWriter pw = getWriter(socket);

                pw.println("From 服务器：欢迎使用服务！");

                String msg = null;
                while ((msg = br.readLine()) != null) {
                    if (msg.trim().equalsIgnoreCase("bye")) {
                        pw.println("From 服务器：服务器已断开连接，结束服务！");

                        System.out.println("客户端离开。");
                        break;
                    }

                    pw.println("From 服务器：" + msg);
                    pw.println("来自服务器,重复消息："+msg);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (socket != null)
                        socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void main(String[] args) throws IOException{
        new TCPThreadServer().Service();
    }

}

最后

本篇将解决了服务端多用户通信的问题，详细记录服务端多线程的实现，目标是多用户（客户端）能够同时与服务器建立连接并通信，避免阻塞，进一步完善TCP的Socket网络通信，运用Java多线程技术，实现多用户与服务端Socket通信！简而言之，相当于多用户访问服务器资源，服务器应该与各个客户端建立连接，就像我们日常使用QQ、微信、视频等客户端，就是多用户与服务器通信的例子。

老问题了，๑乛◡乛๑，好像完成这个之后，可以来实现一个什么有趣的呢？这里停留思考3秒！

……

……

……

就是：实现一个群组聊天房间，类似QQ、微信的群聊，可以多个用户之间的对话交流，是不是感觉挺有趣的。

基于本篇多线程技术实现多用户服务器端的功能，是否能够解决群组聊天房间的功能呢？实现这个功能，等待更新下一篇！

如果觉得不错欢迎“一键三连”哦，点赞收藏关注，有问题直接评论，交流学习！

分享一波福利，跟我一起学习Java，感兴趣的朋友赶紧报名学习哦！

       据说每五行源代码当中就有一行采用Java编写。作为史上应用最广的编程语言，Java无疑是通往开发的第一道关口，如同作文一般，想写出流畅的文章，需先理解语法架构，字词间的逻辑关系。同理，欲写出可编译的Java语言，必先从了解基础语法开始。 精通Java，横向了解软件开发原理，纵向进军Java编程，总是艺多不压身。

        对于一个 Java 程序员而言，能否熟练掌握多线程编程是判断他优秀与否的重要标准之一。因为并发编程是 Java 语言中最为晦涩的知识点，它涉及操作系统、内存、CPU、编程语言等多方面的基础能力，更为考验一个程序员的内功。

Java实现socket通信网络编程系列文章：

1. 基于UDP协议网络Socket编程(java实现C/S通信案例)【https://blog.csdn.net/Charzous/article/details/109016215】
2. 基于TCP协议网络socket编程(java实现C/S通信)【https://blog.csdn.net/Charzous/article/details/109016215】
3. Java多线程实现TCP网络Socket编程(C/S通信)【https://blog.csdn.net/Charzous/article/details/109283697】

我的CSDN博客：https://blog.csdn.net/Charzous/article/details/109440277