如何解决线程安全问题
 
怎么解决线程的安全问题呢？
 
基本上所有解决线程安全问题的方式都是采用“序列化临界资源访问”的方式，即在同一时刻只有一个线程操作临界资源，操作完了才能让其他线程进行操作，也称作同步互斥访问。
 
在Java中一般采用synchronized和Lock来实现同步互斥访问。
 
synchronized关键字
 
首先我们先来了解一下互斥锁，互斥锁：就是能达到互斥访问目的的锁。
 
如果对一个变量加上互斥锁，那么在同一时刻，该变量只能有一个线程能访问，即当一个线程访问临界资源时，其他线程只能等待。
 
在Java中，每一个对象都有一个锁标记（monitor），也被称为监视器，当多个线程访问对象时，只有获取了对象的锁才能访问。
 
在我们编写代码的时候，可以使用synchronized修饰对象的方法或者代码块，当某个线程访问这个对象synchronized方法或者代码块时，就获取到了这个对象的锁，这个时候其他对象是不能访问的，只能等待获取到锁的这个线程执行完该方法或者代码块之后，才能执行该对象的方法。
 
我们来看个示例进一步理解synchronized关键字：
 
public class Example {
    public static void main(String[] args)  {
        final InsertData insertData = new InsertData();
        new Thread() {
            public void run() {
                insertData.insert(Thread.currentThread());
            };
        }.start();
        new Thread() {
            public void run() {
                insertData.insert(Thread.currentThread());
            };
        }.start();
    }  
}
class InsertData {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    public void insert(Thread thread){
        for(int i=0;i<5;i++){
            System.out.println(thread.getName()+"在插入数据"+i);
            arrayList.add(i);
        }
    }
}
 
这段代码的执行是随机的（每次结果都不一样）：
 
Thread-0在插入数据0` `Thread-1在插入数据0` `Thread-1在插入数据1` `Thread-1在插入数据2` `Thread-1在插入数据3` `Thread-1在插入数据4` `Thread-0在插入数据1` `Thread-0在插入数据2` `Thread-0在插入数据3` `Thread-0在插入数据4
 
现在我们加上synchronized关键字来看看执行结果：
 
public synchronized void insert(Thread thread){
     for(int i=0;i<5;i++){
        System.out.println(thread.getName()+"在插入数据"+i);
        arrayList.add(i);
    }
}
 
输出：
 
Thread-0在插入数据0` `Thread-0在插入数据1` `Thread-0在插入数据2` `Thread-0在插入数据3` `Thread-0在插入数据4` `Thread-1在插入数据0` `Thread-1在插入数据1` `Thread-1在插入数据2` `Thread-1在插入数据3` `Thread-1在插入数据4
 
可以发现，线程1会等待线程0插入完数据之后再执行，说明线程0和线程1是顺序执行的。
 
从这两个示例中，我们可以知道synchronized关键字可以实现方法同步互斥访问。
 
在使用synchronized关键字的时候有几个问题需要我们注意：
 
在线程调用synchronized的方法时，其他synchronized的方法是不能被访问的，道理很简单，一个对象只有一把锁；
当一个线程在访问对象的synchronized方法时，其他线程可以访问该对象的非synchronized方法，因为访问非synchronized不需要获取锁，是可以随意访问的；
如果一个线程A需要访问对象object1的synchronized方法fun1，另外一个线程B需要访问对象object2的synchronized方法fun1，即使object1和object2是同一类型），也不会产生线程安全问题，因为他们访问的是不同的对象，所以不存在互斥问题。
 
synchronized代码块
 
synchronized代码块对于我们优化多线程的代码很有帮助，首先我们来看看它长啥样：
 
synchronized(synObject) {}
 
当在某个线程中执行该段代码时，该线程会获取到该对象的synObject锁，此时其他线程无法访问这段代码块，synchronized的值可以是this代表当前对象，也可以是对象的属性，用对象的属性时，表示的是对象属性的锁。
 
有了synchronized代码块，我们可以将上述添加数据的例子修改成如下两种形式：
 
class InsertData {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    public void insert(Thread thread){
        synchronized (this) {
            for(int i=0;i<100;i++){
                System.out.println(thread.getName()+"在插入数据"+i);
                arrayList.add(i);
            }
        }
    }
}
 
上述代码就是synchronized代码块添加锁的两种方式，可以发现添加synchronized代码块，要比直接在方法上添加synchronized关键字更加灵活。
 
当我们用sychronized关键字修饰方法时，这个方法只能同时让一个线程访问，但是有时候很可能只有一部分代码需要同步，而这个时候使用sychronized关键字修饰的方法是做不到的，但是使用sychronized代码块就可以实现这个功能。
 
并且如果一个线程执行一个对象的非static synchronized方法，另外一个线程需要执行这个对象所属类的static synchronized方法，此时不会发生互斥现象，因为访问static synchronized方法占用的是类锁，而访问非static synchronized方法占用的是对象锁，所以不存在互斥现象。
 
来看一段代码：
 
class InsertData {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    private Object object = new Object();
    public void insert(Thread thread){
        synchronized (object) {
            for(int i=0;i<100;i++){
                System.out.println(thread.getName()+"在插入数据"+i);
                arrayList.add(i);
            }
        }
    }
}
 
执行结果：
 
执行insert` `执行insert1` `执行insert1完毕` `执行insert完毕

前言
 
我们紧接着上节ArrayList 线程安全问题讲下HashMap的线程安全问题.
 
之前看书,书中经常会提及.HashTable是线程安全的,HashMap是线程非安全的.在多线程的情况下, HashMap会出现死循环的情况.此外,还会推荐使用新的JUC类 ConcurrentHashMap.
 
今天,我们就将这些幺蛾子一网打尽. 本章, 将主要描述"为什么HashMap是非线程安全的? HashMap在多线程的情况下为什么会出现死循环?"
 
 
正文 - 准备工作
 
在讲解HashMap类的非线程安全问题之前, 我们需要对于HashMap的数据结构要有所了解.
 
通过Eclipse的outline视图,我们瞄一瞄HashMap的源码内的对象.
 
 通过观察,我们可以发现.HashMap主要是维护了一个Enrty类型的数组来存储变量.
 即transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;,其中transient是用于表示不需要序列化的标示,我们不用管他.
 
 static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        int hash;
 }
 
我们在看下Entry类的源码.通过上述的Entry源码,我们可以发现它主要包括几个部分:key/value/hash/next.
 在JDK1.7中的HashMap结构大致如下:
 
 其中的每一块值,是一个Entry类型的链表.(在JDK1.8 之后,当Entry链表的长度多于一定的值的时候,会将其转换为红黑树. PS: 为了在O(log2N)的时间内获取到结点的值. 在JDK1.8内的红黑树也是使用链表进行实现的,不必过于在意.)
 
 
单线程resize操作
 
首先, 与ArrayList类一样, 我们先瞄一瞄HashMap的put方法.
 
public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
        	// 如果table为空的table,我们需要对其进行初始化操作.
            inflateTable(threshold);
        }
        if (key == null)
        	// 如果key为null的话 我们对其进行特殊操作(其实是放在table[0])
            return putForNullKey(value);
        // 计算hash值
        int hash = hash(key);
        // 根据hash值获取其在table数组内的位置.
        int i = indexFor(hash, table.length);
        // 遍历循环链表(结构图类似上图)
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            // 如果找到其值的话,将原来的值进行覆盖(满足Map数据类型的特性.)
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
		// 如果都没有找到相同都key的值, 那么这个值是一个新值.(直接进行插入操作.)
        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }
 
跟随其后,我们深入addEntry(hash, key, value, i);方法一探究竟吧.
 
    void addEntry(int hash, K key, V value, int bucketIndex) {
        if ((size >= threshold) && (null != table[bucketIndex])) {
        	// 如果其大小超过threshold 并且table[index]的位置不为空
        	// 扩充HashMap的数据结果为原来的两倍
            resize(2 * table.length);
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }

        createEntry(hash, key, value, bucketIndex);
    }
 
PS: mountCount/size/threshold的联系与区别?
 
紧随其后,进入人们经常说的resize()方法.
 
    void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
        	//capacity 容量
            threshold = Integer.MAX_VALUE;
            return;
        }
		// 创建一个新的对象
        Entry[] newTable = new Entry[newCapacity];
        // 将旧的对象内的值赋值到新的对象中
        transfer(newTable, initHashSeedAsNeeded(newCapacity));
        table = newTable;
        // 重新赋值新的临界点
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }
    
    void transfer(Entry[] newTable, boolean rehash) {
    	// 新table的长度
        int newCapacity = newTable.length;
        for (Entry<K,V> e : table) {
            while(null != e) {
                Entry<K,V> next = e.next;
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity);
                e.next = newTable[i];
                newTable[i] = e;
                e = next;
            }
        }
    }
 
这么一看,主要的resize()方法的转换操作都在transfer()方法内.我们详细的画图了解下这个循环.
 
for (Entry<K,V> e : table) {}外层循环,循环遍历旧table的每一个值.这不难理解,因为要将旧table内的值拷贝进新table.
链表拷贝操作.主要是四行代码.e.next = newTable[i]; newTable[i] = e; e = next;这个操作一下子比较难懂,我们画图了解一下.
 
 这个图还是有点抽象 我们再将细节进行细分.
 

 1 next = e.next,目的是记录下原始的e.next的地址.图上为Entry-1-1.
 2 e.next = newTable[i],也就是将newTable[3]替代了原来的entry1-1.目的是为了记录原来的newTable[3]的链表头.
 3 newTable[i] = e,也就死将entry1-0替换成新的链表头.
 4. e = next;,循环遍历指针.将e = entry1-1.开始处理entry1-1.
 将步骤细分后,我们可以得到如下:
 
 由上述的插入过程,我们可以看出.这是一个倒叙的链表插入过程.
 (比如 1-0 -> 1-1 ->1-2 插入后将变为 1-2 -> 1-1 -> 1-0)
 
 
多线程操作 - 分析线程安全?线程非安全?
 
因为倒叙链表插入的情况,导致HashMap在resize()的情况下,导致链表出现环的出现.一旦出现了环那么在while(null != p.next){}的循环的时候.就会出现死循环导致线程阻塞.那么,多线程的时候,为什么会出现环状呢?让我们看下面的例子:
 
首先有2个线程,由上一节我们知道,在resize()的过程中,一共有如下四个步骤:
 
Entry<K,V> next = e.next;
e.next = newTable[i];
newTable[i] = e;
e = next;
 
我们有两个线程,线程A与线程B.线程A在执行Entry<K,V> next = e.next;之后,也就是第一个步骤之后,线程阻塞停止了.线程B之间进行了重排序的操作.此时的HashMap内部情况如下所示:
 
初始(A阻塞 B运行完毕)
 
A唤醒 e=key(3)
 A的执行步骤如下: 
  
线程阻塞前记录 next = key(7)
线程唤醒后执行 newTable[3]=null; key(3).next=null;
newTable[3]=key(3);
e=next; 即 e = key(7);
 
 
A唤醒 e=key(7) 
  
next = key(3)
newTable[3]=key(3); key(7).next=key(3);
newTable[3]=key(7);
e=next; 即 e = key(3);
 
 
A唤醒 e=key(3) 
  
next = key(3).next; 即 next = null;
newTable[3]=key(7); key(3).next=key(7);
newTable[3]=key(3);
e=next; 即 e = null; 循环结束.但是此时已经形成了环路.
 
 
 
 
Tips
 
 
 
链表出现环?
 快,慢指针方法.判断链表中是否有环 ----- 有关单链表中环的问题
 
 
 
 
size、capacity、threshold与loadFactor?
 
 
size为hashMap内的链表结点数目.即Entry对象的个数(包括链表内).
capacity为桶的数目.(即Enrty<k,v> []table的长度) static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
loadFactor 过载因子static final float DEFAULT_LOAD_FACTOR = 0.75f;
threshold 边界值.高于边界值,则HashMap进行resize操作.The next size value at which to resize (capacity * load factor). 定义int threshold;
 
 
 
Reference
 
[1]. HashMap 在 JDK 1.8 后新增的红黑树结构
 [2]. （1）美团面试题：Hashmap的结构，1.7和1.8有哪些区别，史上最深入的分析
 [3]. Java7/8 中的 HashMap 和 ConcurrentHashMap 全解析
 [4]. HashMap？面试？我是谁？我在哪
 [5]. JDK7与JDK8中HashMap的实现
 [6]. 谈谈HashMap线程不安全的体现
 [7]. ConcurrentHashMap源码分析(JDK1.7和JDK1.8)
 [8]. HashMap中capacity、loadFactor、threshold、size等概念的解释

背景
 
几年前在CSDN的C币商城换购过一本《白帽子讲Web安全》，了解过Web网站在渗透测试过程中常见的安全问题。近来，自己开发的Java Web应用中存在一些安全漏洞，被迫要求关注这些安全隐患、并加固。
 
那么本文就顺便整理一下Java Web开发过程中容易忽略的几个安全问题吧，这些问题都能搜到，并且加固方式也不复杂。初学者或者对安全要求不高的开发流程中，很可能被忽略。
 
密码明文传输
 
当年初学Java Web时，简单的信息管理系统中，根本没有安全意识。仅仅靠表单的password类型掩盖了密码的表面形象而已。
 
但是，在实际应用中，这是个大问题，最初也知道这个问题，只是鉴于应用用户较少，而且只能处于内网环境中，就直接忽略了。但是表单中明文传送密码，的确不应该。最简单的方式是密码通过js加密传递到后台，然后Controller校验时直接取数据库中的密文进行匹配。
 
用户名被猜中
 
这个问题可能出现在密码校验逻辑中：校验结果的不同分支，返回给页面提示信息不同，密码错误和用户名不存在是两个不同分支中的。这样依一来，居心叵测者就可能通过多次输入并提交而猜中系统中可能存在的用户名。
 
这一点，Linux用户，Oracle用户，数据表的校验，处理都很高明，能预防敏感信息泄漏。（这点没有考证，初入职场时的入职培训老师讲过这些，印象较深刻，整理本文时就想起这几方面了。如有错误，欢迎指正!）
 
 
 
1 Linux的登录错误提示信息是统一的：用户名或密码错误！ 
 2 文件目录一旦输入错误：统一提示文件或目录不存在的。 
 3 Oracle数据库查询操作查询时，如果表名称错误，提示信息是表不存在。
 
 
文件上传
 
文件上传最好使用专门的文件服务器，与当前web应用隔离开。如果条件不允许，应该用独于Web应用部署目录之外的目录，这样攻击者就不能通过web服务器内部的目录结构获取用户上传的文件信息了。
 
其次，对上传的文件的校验，处理页面空间的限制外，后台Controller也许要对对文件进行校验，比如文件名或这文件内容。因为攻击者发送的请求不是通过页面完成的，而是模拟表单请求的话，文件名称就可以是任意的。
 
所以，后台也应该对用户请求中的上传文件名称进行校验，保证只有系统允许的文件内容才能被处理。
 
文件下载
 
凡是涉及到文件下载的地方，应该提高安全意识，编码过程中，校验下载文件名称。应用下载文件的根目录应该是固定的，而且文件名称只能是最终名称，不能包含路径“.”的。
 
 
 
http://xxx/xxxx/download?fileName=./../.././../.././../.././../.././../.././../..//etc/passwd
 
 
如果一个文件下载请求中，直接使用用户请求的fileName参数，而不经过任何安全校验的话，那么不法分子就可能通过上述模拟请求下载到Linux服务器的密码文件。
 
加固措施为：校验文件名称参数，不能是包含路径的文件名称，只能是简单名称或者路径固定，即项目指定存放下载文件的路径。
 
表单输入校验
 
不能对用户的输入过于信任，所有的需要用户输入的地方，应该添加验证。例如：用户可以在一个input表单中输入js代码：
 
<script>   alert(new Date());
</script>
 
这就是典型的CRSF，跨站请求伪造；此外，如果一个input输入框里面，用户输入了html标签
 
</button>
 
而后台又没有进行任何拦截处理，那么该表单数据回显的时候，页面就会多一个button按钮了。
 
解决办法：可以在前端统一对页面的input进行限制不能输入html标签；然后在Controller层使用Filter，对用户输入的请求头域的数据进行预处理，拦截或者过滤输入信息中的有害数据。
 
重要模块的CRSF
 
在任何一个登录后的页面上，进入一个敏感数据添加页面如：用户添加页面。输入表单信息之后，将页面源码扒下来，存储htm文件，点击htm文件的表单提交，就可以通过CRSF表单提交数据到指定服务器。
 
敏感信息的所有操作应该添加token信息，这点我想起了微信工作平台开发API中，所有的操作都是需要Token信息的，那么这里Token的作用应该是一样的，防止攻击者伪造表单请求。
 
服务器版本信息泄漏
 
下图404页面，开发过程中经常见到，但是它会对Web应用造成什么威胁呢？
 
 
显然，它泄漏Web应用服务器的信息。攻击者在知道应用的服务器信息后，就可能利用对应版本的服务器的漏洞，发起进一步攻击行为。
 
这个问题主要是web应用的404、500等常见错误页面信息的配置不当导致的。增强安全意识，应该避免使用服务器默认的错误页面信息，在web.xml中增加自定义的错误页面配置信息。
 
    <!-- 配置系统错误显示的页面 -->
    <error-page>
        <error-code>500</error-code>
        <location>/error/500.html</location>
    </error-page>
    <error-page>
        <error-code>404</error-code>
        <location>/error/404.html</location>
    </error-page>
 
启示录
 
安全是一件大事，如果一点都没有注意的话，我们的Java Web应用是不是分分钟就能被攻击者黑掉呢？ 
 想起以前遇到过iteye这个网站被黑掉添加很多垃圾信息的情况. 
 树立安全意识，Too simple ! Too dangerous!

企业网络安全最常遇到的问题是什么?答案并非微不足道。基于网络安全评估的统计数据可能是关于这一复杂主题的最佳知识库。行业专家在开展这项活动方面具有扎实的背景，几乎每个企业IT环境都可能发现以下威胁：
 
1.电子邮件中的病毒
 
安全检查不仅可以监控用户的流量，还可以帮助企业检查所有电子邮件。企业可以做的不仅仅是过滤垃圾邮件，还能够检查邮件正文中的附件和链接。这种控制很容易实现。只需将邮件服务器配置为将所有电子邮件副本转发到正在运行MTA(邮件传输代理)的CheckPoint。如果使用的是Exchange企业电子邮件服务，则可以使用密件抄送(Bcc)。这种方法的主要好处是企业在用户的反垃圾邮件解决方案过滤后检查电子邮件。然而，令人感觉奇怪的是，总是不断通过恶意邮件。电子邮件流量安全的当前机制在大多数情况下根本无法应对这种任务。
 
为什么电子邮件病毒会有危险?
 
根据最新报告，电子邮件继续在恶意软件分发生态系统中占主导地位。恶意代码可以作为附件文件查收，也可以通过指向随机在线资源(如GoogleDrive)的链接进行轮询。在病毒传播方面，SMTP流量优于其他协议。此外，病毒不一定是.exe文件，它们也可以伪装成用户通常信任的.doc或.pdf文档。
 
2.网络钓鱼
 
几乎所有评估都会发现员工点击网络钓鱼链接遭遇攻击的实例。PayPai、Office356、Fasebook、Appie等网站有着无数的网络钓鱼链接，试图吸引用户。网络钓鱼攻击的载体正在急剧上升，其原因很简单：如果可以简单地欺骗一个轻信的用户，为什么要制造复杂的病毒呢?人类永远是企业网络安全中最薄弱的环节。
 
是什么让网络钓鱼如此危险?
 
网络钓鱼在某种程度上是用户的个人问题。一旦有人打开网络钓鱼链接遭受损失，就会提高警惕。但攻击者可能会以这种方式窃取企业数据，其中包括电子邮件地址、密码和重要文件。许多人重复使用公司提供的用户名和密码来注册公共站点，例如社交网络和torrent文件的洪流跟踪器。如果用户可以在其所有账户使用同一个密码，为什么要记住一堆密码呢?这可能是他们的想法。
 
3.从企业网络上传到云端
 
云存储(Dropbox、GoogleDrive等)是另一个IT安全问题。现在每个人都使用这些服务。但是要知道企业网络中的某个人使用它们是一回事，而在这些渠道上浪费数GB的流量则是另一回事。大约80%被评估的公司都遇到了这个问题。
 
是什么让这样的上传数据有害?
 
有人可能正在泄露公司数据。除非采用数据泄露防护(DLP)解决方案，否则无法看到究竟泄露了什么。但是，不仅是将数据上传到云资源会带来风险，下载数据同样有害。黑客多年来一直在通过公共文件存储库传播病毒。
 
4.远程访问工具
 
这是另一个令人不安的事实。在绝大多数公司中，有些人使用远程访问服务，例如TeamViewer。但没有人能保证是远程访问其工作计算机的人员。它可能是企业原来的员工或网络犯罪分子。
 
远程访问工具的风险是什么?
 
除了未经批准的访问之外，还面临一个风险：文件传输。尤其令人不安的是，在这些会话过程中，大量的流量(GB级数据)来回传输移动。大多数远程访问实用程序都具有加密措施，因此无法了解正在下载或上传的内容。不过，总的来说，它是私有数据泄漏的主要渠道。
 
5.员工使用VPN工具和代理
 
只使用InternetExplorer访问已添加书签的网站的传统做法已经落后。如今的做法已经变得更加高级，再也不能用代理和匿名者来迷惑他人。安全评估显示，许多企业员工几乎都使用Tor或VPN。他们使用这些工具在组织中阻止玩游戏或观看非法视频。除非组织采用保护IT周边的下一代防火墙(NGFW)，否则几乎不可能阻止。
 
使用VPN的风险是什么?
 
员工滥用内部指南这一事实并不是使用VPN最危险的事情。最大的担忧是加密流量将渗透到网络边界。即使企业拥有适用于防病毒和IPS功能的高效边缘设备，也无法跟踪这样的活动。用户可以通过加密通道传输任何内容，其中包括恶意软件。此外，他们可能不知道他们正在下载恶意内容，而这同样适用于HTTPS流量。如果没有在网络边界使用安全套接层(SSL)检查，则会出现与Internet带宽相当的安全漏洞。
 
许多IT安全管理人员都惊讶地发现，很多人通过匿名化工具在网络中传输大量的信息，而通过这些渠道传输内容很可能是一个谜。
 
6.Torrents
 
在几乎所有调查的公司中，一些人使用BitTorrent或其他P2P服务下载文件。而且，以这种方式下载的数据量是巨大的。在一个案例中，员工每周下载2TB的数据。人们可能会认为每个人都可以在家中使用高速互联网，那么为什么要在公司下载数据?
 
是什么让Torrents变得危险?
 
采用Torrents下载的主要问题是堵塞互联网的带宽。这种拥塞通常会影响业务关键型解决方案，例如IP电话和公司的云计算服务(CRM、电子邮件等)。此外，在计划购买外围防火墙时，许多管理人员根据渠道负载统计数据做出选择。例如，企业发现上个月的平均负载大约为400Mbps，因此决定购买功能更强大(因此更加昂贵)的防火墙。但是，如果阻止所有未经授权的P2P流量，可以在下一代防火墙(NGFW)部署方面节省大量资金。
 
最重要的是，几乎所有通过种子下载的文件都是较大文件的片段，这使得监控此类流量成为防病毒和IPS系统的问题。
 
7.僵尸网络
 
在90%的案例中，受感染的计算机是僵尸网络的组成部分。从技术上讲，其文件没有被删除、加密或泄露。然而，在被污染的系统中，有一个很小的实用程序等待命令和控制服务器的指令。值得一提的是，这可能存在误报，其中安全解决方案将常规流量识别为僵尸网络的标志。无论如何，每一次这样的事件都要经过严格的调查。
 
是什么让僵尸服务器变得危险?
 
受感染的服务器可以在企业的网络内运行多年而不会暴露。它们可能永远不会造成伤害，但是很难预见到它们可能造成的影响。例如，这些服务器可能会下载加密勒索软件，并用它攻击整个网络。
 
8.观看非法视频
 
无论听起来多么奇怪，一些人在工作时间中观看非法视频。此外，这种流量是十分巨大的。在其中一次检查中，测试人员发现一名员工在两周内观看了26GB的视频。
 
为什么非法内容在工作中具有危险性?
 
这个问题起初看起来可能很有趣。如果将其从道德和伦理中脱离出来，那么问题在于用户在这种娱乐上花费太多时间。一般来说，诸如YouTube、社交媒体和信使之类的服务与工作效率并不匹配，尽管这个问题会带来一些争议。因此，企业需要评估可以帮助用户找出谁在浪费他们的工作时间，以及他们究竟在做什么。
 
其他问题
 
针对企业数字基础设施的DDoS攻击
 
基于漏洞的攻击
 
网络犯罪分子不仅可以攻击用户的电脑，还能够攻击企业的服务器。当然，还有许多其他的事件，其中用户下载恶意软件(包括零日感染)，由于它们的体系结构更加复杂，并且需要更仔细的分析(毕竟还应该考虑误报的可能性)，当前防御系统无法检测到这些。
 
总结
 　　以上就是企业安全面临的主要八大问题。最重要的是要记住，信息安全是一个持续的过程，而不是结果。
 　　人工智能、大数据、云计算和物联网的未来发展值得重视，均为前沿产业，多智时代专注于人工智能和大数据的入门和科谱，在此为你推荐几篇优质好文：
 云计算时代，网络安全技术有哪些？
http://www.duozhishidai.com/article-1878-1.html
 大数据时代，主要存在哪些网络安全问题？
http://www.duozhishidai.com/article-1241-1.html
 网络安全正面临4个挑战
http://www.duozhishidai.com/article-12774-1.html
 
 
多智时代-人工智能和大数据学习入门网站|人工智能、大数据、物联网、云计算的学习交流网站