指纹锁：“锁”不住的危险_网易新闻
指纹锁：“锁”不住的危险
用微信扫码二维码
分享至好友和朋友圈
前段时间央视《每周质量报告》的一个视频让很多居民为自己的家门和门锁感到深深的忧虑，小偷行窃居然直接开锁进入，无需撬锁或者攀爬窗户，防盗门和防盗锁都挡不住的危险。小偷的作案工具直接在非法途径网上购买，我们的门锁还能所的住家里的安全吗？
一些指纹锁厂家对此都宣称，指纹锁才是最安全，只有唯一性的生物识别指纹锁才能打开门锁，小偷对指纹锁根本束手无策。这看似很合理，然而并非真实，因为指 纹锁一样是可以被钥匙直接打开的。按照中国公安部的标准，任何指纹锁在出厂的时候都必须配有机械锁芯在门外，以防指纹锁系统故障或者密码无法开锁的时候， 钥匙可以开机械锁芯。也就是说，指纹锁开锁：指纹、感应刷卡、密码、钥匙，其中密码和钥匙是备用。一般使用指纹锁和感应刷卡开门。所以，指纹锁不是一定得 用指纹才能开锁，也不是绝对的安全存在。
一些指纹锁厂商开发了能报警的指纹锁，一旦指纹锁被暴力撬开或者非法输入错误指纹锁，门锁就自动报警鸣笛，吓退盗贼，引起警戒。这个看起来很先进吗，也很 智能化，那么是否真的如此呢？小编请专业的开锁师傅测试一款有报警功能指纹锁，利用开锁工具打开指纹锁，工具直接插入指纹锁的机械锁芯，从头到尾都没有碰 到指纹识别器或者对门锁有暴力开锁的行为，开锁师傅直接利用工具把机械锁芯打开了，用时大约是2分钟，指纹锁被毫发无损地打开了，看来指纹锁也并非绝对安全。
根据目前市场的门锁类别和价格，一般可以区分为A级锁、B级锁、超B级锁、C级防盗锁，A级锁是目前全国家庭最多使用的锁，占全国家庭门锁使用率的80%，B级锁也是防盗锁，超B级锁为更复杂的防盗锁，以此类推。A级锁的价格一般在50-80元之间，而B级锁的价格则往往是A级锁的两倍以上，更不用说超B级锁了，昂贵的价格与门锁安全意识不足是家庭门锁更新换代的主要阻力。
根据市面上一些开锁公司师傅的介绍，一般给客户开锁的锁芯大多为A级锁，B级锁不多，更别说超B级锁了。一般A级锁的开锁时间不到2分钟就可以轻松解决，B级锁3-5分钟，超B级锁比较复杂，开锁难度大，但是很少会有居民用超B锁，因为价格很昂贵。指纹锁的机械锁芯也是***的A级、B级或者超B级锁，指纹锁的价格体现的不单单是指纹锁的外观设计和指纹识别系统的先进，更多是体现机械锁芯的安全等级。
如何防范指纹锁被非法打开呢？指纹锁真的安全了吗？
小编带大家分析一下目前市场上指纹锁行情和安全级性能；中国指纹锁市场目前是一片大好，销量也是在逐年提升，这与中国经济发展和居民收入的提升离不开。指 纹锁的普及，一般为中国的新兴家庭，喜欢时尚和智能便捷的家庭，或者是为了安全会更换。中国的指纹锁市场也是外来品牌长期占领的局面，近年中国自主品牌指 纹锁崛起，技术与品牌的大力提升，让更多的国产品牌指纹锁走进中国居民的生活，而不再崇洋媚外，国货当自强。然而，无论是国货还是洋货，这些指纹锁真的能 确保我们的家门的安全吗？指纹锁能被技术人员毫发无伤地开打，是因为指纹锁的机械锁芯安全系数不够高，如果把锁芯更换成高级的锁芯，指纹锁的价格便会变得 昂贵无比，一般居民都消费不起。
针对目前指纹锁的技术与安全，只有个别指纹锁品牌才创新门锁安全，重视指纹锁安全，而其他的品牌指纹锁则注重销量与版本，为不同的门做出不同外观和价格的 指纹锁以促进产品的销售。我们买回来的门锁无论是机械锁还是指纹锁，我们的目的都是一样：家庭安全；大门是我们一家人安全的守护神，门锁则是守护神的心 脏。如果我们买回来的门锁都无法确保我们的人身与财产安全，要那么漂亮、那么昂贵的指纹锁又有什么作用呢？一个形同虚设的指纹锁看似智能，其实能被窃贼利 用工具秒开，如此门锁还真的能保护我们吗？
专注安防智能领域的慑力科技公司，旗下开发的全球雷达指纹锁，在等同的指纹锁的基础上对指纹锁进行了技术升级和创新：智能防盗锁。全球雷达品牌指纹锁，把 门锁的智能化结合到手机中，第五种开锁功能；手机远程开锁，避免朋友或者其他熟人无钥匙和指纹蹲守家门等待的尴尬。结合智能安防技术，手机远程监控门锁情 况。全球雷达指纹锁先进之处更是在于窃贼无法接近门锁，更无法开锁，即使有作案工具也无法打开全球雷达指纹锁。指纹锁的设置为门锁预警时间，只有录入指纹 锁的人才能打开门锁，安全撤防。如果没有录入指纹而接近门锁，门锁便会警示其离开，如果其强行尝试开锁，便会自动报警会鸣笛，拍照并发送到主人手机，通知 主人。
居民需要提升门锁安全意识，指纹锁厂家需提升门锁技术创新，这样才能让我们的人身安全与财产安全得到保障。一些品牌指纹锁一直吹嘘自己的品牌知名度与指纹 技术的高超，门锁版本的多样化，而没有真正考虑到门锁对一个家庭的潜在重要性。消费者无论购买何种品牌指纹锁，出发都是一致的：安全。消费者只认实用又安 全的东西，普通的老百姓都会选使用又安全的门锁来保障自己家人的安全。
本文来源：山西新闻网
责任编辑：王晓易_NE0011
用微信扫码二维码
分享至好友和朋友圈
加载更多新闻
热门产品:　　　
:　　　　　　　　
:　　　　　　　　　
热门影院：
阅读下一篇
用微信扫描二维码
分享至好友和朋友圈高并发Java（9）：锁的优化和注意事项 - ImportNew
1. 锁优化的思路和方法
在中有提到并发的级别。
一旦用到锁，就说明这是阻塞式的，所以在并发度上一般来说都会比无锁的情况低一点。
这里提到的锁优化，是指在阻塞式的情况下，如何让性能不要变得太差。但是再怎么优化，一般来说性能都会比无锁的情况差一点。
这里要注意的是，在中提到的ReentrantLock中的tryLock，偏向于一种无锁的方式，因为在tryLock判断时，并不会把自己挂起。
锁优化的思路和方法总结一下，有以下几种。
减少锁持有时间
减小锁粒度
1.1 减少锁持有时间
public synchronized void syncMethod(){
othercode1();
mutextMethod();
othercode2();
像上述代码这样，在进入方法前就要得到锁，其他线程就要在外面等待。
这里优化的一点在于，要减少其他线程等待的时间，所以，只用在有线程安全要求的程序上加锁
public void syncMethod(){
othercode1();
synchronized(this)
mutextMethod();
othercode2();
1.2 减小锁粒度
将大对象（这个对象可能会被很多线程访问），拆成小对象，大大增加并行度，降低锁竞争。降低了锁的竞争，偏向锁，轻量级锁成功率才会提高。
最最典型的减小锁粒度的案例就是ConcurrentHashMap。这个在有提到。
1.3 锁分离
最常见的锁分离就是读写锁ReadWriteLock，根据功能进行分离成读锁和写锁，这样读读不互斥，读写互斥，写写互斥，即保证了线程安全，又提高了性能，具体也请查看。
读写分离思想可以延伸，只要操作互不影响，锁就可以分离。
比如LinkedBlockingQueue
从头部取出，从尾部放数据。当然也类似于中提到的ForkJoinPool中的工作窃取。
1.4 锁粗化
通常情况下，为了保证多线程间的有效并发，会要求每个线程持有锁的时间尽量短，即在使用完公共资源后，应该立即释放锁。只有这样，等待在这个锁上的其他线程才能尽早的获得资源执行任务。但是，凡事都有一个度，如果对同一个锁不停的进行请求、同步和释放，其本身也会消耗系统宝贵的资源，反而不利于性能的优化 。
举个例子：
public void demoMethod(){
synchronized(lock){
//做其他不需要的同步的工作，但能很快执行完毕
synchronized(lock){
这种情况，根据锁粗化的思想，应该合并
public void demoMethod(){
//整合成一次锁请求
synchronized(lock){
//做其他不需要的同步的工作，但能很快执行完毕
当然这是有前提的，前提就是中间的那些不需要同步的工作是很快执行完成的。
再举一个极端的例子：
for(int i=0;i&CIRCLE;i++){
synchronized(lock){
在一个循环内不同得获得锁。虽然JDK内部会对这个代码做些优化，但是还不如直接写成
synchronized(lock){
for(int i=0;i&CIRCLE;i++){
当然如果有需求说，这样的循环太久，需要给其他线程不要等待太久，那只能写成上面那种。如果没有这样类似的需求，还是直接写成下面那种比较好。
1.5 锁消除
锁消除是在编译器级别的事情。
在即时编译器时，如果发现不可能被共享的对象，则可以消除这些对象的锁操作。
也许你会觉得奇怪，既然有些对象不可能被多线程访问，那为什么要加锁呢？写代码时直接不加锁不就好了。
但是有时，这些锁并不是程序员所写的，有的是JDK实现中就有锁的，比如Vector和StringBuffer这样的类，它们中的很多方法都是有锁的。当我们在一些不会有线程安全的情况下使用这些类的方法时，达到某些条件时，编译器会将锁消除来提高性能。
public static void main(String args[]) throws InterruptedException {
long start = System.currentTimeMillis();
for (int i = 0; i & 2000000; i++) {
createStringBuffer(&JVM&, &Diagnosis&);
long bufferCost = System.currentTimeMillis() -
System.out.println(&craeteStringBuffer: & + bufferCost + & ms&);
public static String createStringBuffer(String s1, String s2) {
StringBuffer sb = new StringBuffer();
sb.append(s1);
sb.append(s2);
return sb.toString();
上述代码中的StringBuffer.append是一个同步操作，但是StringBuffer却是一个局部变量，并且方法也并没有把StringBuffer返回，所以不可能会有多线程去访问它。
那么此时StringBuffer中的同步操作就是没有意义的。
开启锁消除是在JVM参数上设置的，当然需要在server模式下：
-server -XX:+DoEscapeAnalysis -XX:+EliminateLocks
并且要开启逃逸分析。 逃逸分析的作用呢，就是看看变量是否有可能逃出作用域的范围。
比如上述的StringBuffer，上述代码中craeteStringBuffer的返回是一个String，所以这个局部变量StringBuffer在其他地方都不会被使用。如果将craeteStringBuffer改成
public static StringBuffer craeteStringBuffer(String s1, String s2) {
StringBuffer sb = new StringBuffer();
sb.append(s1);
sb.append(s2);
那么这个 StringBuffer被返回后，是有可能被任何其他地方所使用的（譬如被主函数将返回结果put进map啊等等）。那么JVM的逃逸分析可以分析出，这个局部变量 StringBuffer逃出了它的作用域。
所以基于逃逸分析，JVM可以判断，如果这个局部变量StringBuffer并没有逃出它的作用域，那么可以确定这个StringBuffer并不会被多线程所访问，那么就可以把这些多余的锁给去掉来提高性能。
当JVM参数为：
-server -XX:+DoEscapeAnalysis -XX:+EliminateLocks
craeteStringBuffer: 302 ms
JVM参数为：
-server -XX:+DoEscapeAnalysis -XX:-EliminateLocks
craeteStringBuffer: 660 ms
显然，锁消除的效果还是很明显的。
2. 虚拟机内的锁优化
首先要介绍下对象头，在JVM中，每个对象都有一个对象头。
Mark Word，对象头的标记，32位（32位系统）。
描述对象的hash、锁信息，垃圾回收标记，年龄
还会保存指向锁记录的指针，指向monitor的指针，偏向锁线程ID等。
简单来说，对象头就是要保存一些系统性的信息。
2.1 偏向锁
所谓的偏向，就是偏心，即锁会偏向于当前已经占有锁的线程 。
大部分情况是没有竞争的（某个同步块大多数情况都不会出现多线程同时竞争锁），所以可以通过偏向来提高性能。即在无竞争时，之前获得锁的线程再次获得锁时，会判断是否偏向锁指向我，那么该线程将不用再次获得锁，直接就可以进入同步块。
偏向锁的实施就是将对象头Mark的标记设置为偏向，并将线程ID写入对象头Mark
当其他线程请求相同的锁时，偏向模式结束
JVM默认启用偏向锁 -XX:+UseBiasedLocking
在竞争激烈的场合，偏向锁会增加系统负担（每次都要加一次是否偏向的判断）
偏向锁的例子：
import java.util.L
import java.util.V
public class Test {
public static List&Integer& numberList = new Vector&Integer&();
public static void main(String[] args) throws InterruptedException {
long begin = System.currentTimeMillis();
int count = 0;
int startnum = 0;
while (count & ) {
numberList.add(startnum);
startnum += 2;
long end = System.currentTimeMillis();
System.out.println(end - begin);
Vector是一个线程安全的类，内部使用了锁机制。每次add都会进行锁请求。上述代码只有main一个线程再反复add请求锁。
使用如下的JVM参数来设置偏向锁：
-XX:+UseBiasedLocking -XX:BiasedLockingStartupDelay=0
BiasedLockingStartupDelay表示系统启动几秒钟后启用偏向锁。默认为4秒，原因在于，系统刚启动时，一般数据竞争是比较激烈的，此时启用偏向锁会降低性能。
由于这里为了测试偏向锁的性能，所以把延迟偏向锁的时间设置为0。
此时输出为9209
下面关闭偏向锁：
-XX:-UseBiasedLocking
输出为9627
一般在无竞争时，启用偏向锁性能会提高5%左右。
2.2 轻量级锁
Java的多线程安全是基于Lock机制实现的，而Lock的性能往往不如人意。
原因是，monitorenter与monitorexit这两个控制多线程同步的bytecode原语，是JVM依赖操作系统互斥(mutex)来实现的。
互斥是一种会导致线程挂起，并在较短的时间内又需要重新调度回原线程的，较为消耗资源的操作。
为了优化Java的Lock机制，从Java6开始引入了轻量级锁的概念。
轻量级锁（Lightweight Locking）本意是为了减少多线程进入互斥的几率，并不是要替代互斥。
它利用了CPU原语Compare-And-Swap(CAS，汇编指令CMPXCHG)，尝试在进入互斥前，进行补救。
如果偏向锁失败，那么系统会进行轻量级锁的操作。它存在的目的是尽可能不用动用操作系统层面的互斥，因为那个性能会比较差。因为JVM本身就是一个应用，所以希望在应用层面上就解决线程同步问题。
总结一下就是轻量级锁是一种快速的锁定方法，在进入互斥之前，使用CAS操作来尝试加锁，尽量不要用操作系统层面的互斥，提高了性能。
那么当偏向锁失败时，轻量级锁的步骤：
1.将对象头的Mark指针保存到锁对象中（这里的对象指的就是锁住的对象，比如synchronized (this){}，this就是这里的对象）。
lock-&set_displaced_header(mark);
2.将对象头设置为指向锁的指针（在线程栈空间中）。
if (mark == (markOop) Atomic::cmpxchg_ptr(lock, obj()-&mark_addr(),mark))
TEVENT (slow_enter: release stacklock) ;
lock位于线程栈中。所以判断一个线程是否持有这把锁，只要判断这个对象头指向的空间是否在这个线程栈的地址空间当中。
如果轻量级锁失败，表示存在竞争，升级为重量级锁（常规锁），就是操作系统层面的同步方法。在没有锁竞争的情况，轻量级锁减少传统锁使用OS互斥量产生的性能损耗。在竞争非常激烈时（轻量级锁总是失败），轻量级锁会多做很多额外操作，导致性能下降。
2.3 自旋锁
当竞争存在时，因为轻量级锁尝试失败，之后有可能会直接升级成重量级锁动用操作系统层面的互斥。也有可能再尝试一下自旋锁。
如果线程可以很快获得锁，那么可以不在OS层挂起线程，让线程做几个空操作（自旋），并且不停地尝试拿到这个锁（类似tryLock），当然循环的次数是有限制的，当循环次数达到以后，仍然升级成重量级锁。所以在每个线程对于锁的持有时间很少时，自旋锁能够尽量避免线程在OS层被挂起。
JDK1.6中-XX:+UseSpinning开启
JDK1.7中，去掉此参数，改为内置实现
如果同步块很长，自旋失败，会降低系统性能。如果同步块很短，自旋成功，节省线程挂起切换时间，提升系统性能。
2.4 偏向锁，轻量级锁，自旋锁总结
上述的锁不是Java语言层面的锁优化方法，是内置在JVM当中的。
首先偏向锁是为了避免某个线程反复获得/释放同一把锁时的性能消耗，如果仍然是同个线程去获得这个锁，尝试偏向锁时会直接进入同步块，不需要再次获得锁。
而轻量级锁和自旋锁都是为了避免直接调用操作系统层面的互斥操作，因为挂起线程是一个很耗资源的操作。
为了尽量避免使用重量级锁（操作系统层面的互斥），首先会尝试轻量级锁，轻量级锁会尝试使用CAS操作来获得锁，如果轻量级锁获得失败，说明存在竞争。但是也许很快就能获得锁，就会尝试自旋锁，将线程做几个空循环，每次循环时都不断尝试获得锁。如果自旋锁也失败，那么只能升级成重量级锁。
可见偏向锁，轻量级锁，自旋锁都是乐观锁。
3. 一个错误使用锁的案例
public class IntegerLock {
static Integer i = 0;
public static class AddThread extends Thread {
public void run() {
for (int k = 0; k & 100000; k++) {
synchronized (i) {
public static void main(String[] args) throws InterruptedException {
AddThread t1 = new AddThread();
AddThread t2 = new AddThread();
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
一个很初级的错误在于，在 提到，Interger是final不变的，每次++后，会产生一个新的 Interger再赋给i，所以两个线程争夺的锁是不同的。所以并不是线程安全的。
4. ThreadLocal及其源码分析
这里来提ThreadLocal可能有点不合适，但是ThreadLocal是可以把锁代替的方式。所以还是有必要提一下。
基本的思想就是，在一个多线程当中需要把有数据冲突的数据加锁，使用ThreadLocal的话，为每一个线程都提供一个对象实例。不同的线程只访问自己的对象，而不访问其他的对象。这样锁就没有必要存在了。
import java.text.ParseE
import java.text.SimpleDateF
import java.util.D
import java.util.concurrent.ExecutorS
import java.util.concurrent.E
public class Test {
private static final SimpleDateFormat sdf = new SimpleDateFormat(
&yyyy-MM-dd HH:mm:ss&);
public static class ParseDate implements Runnable {
int i = 0;
public ParseDate(int i) {
public void run() {
Date t = sdf.parse(& 17:00:& + i % 60);
System.out.println(i + &:& + t);
} catch (ParseException e) {
e.printStackTrace();
public static void main(String[] args) {
ExecutorService es = Executors.newFixedThreadPool(10);
for (int i = 0; i & 1000; i++) {
es.execute(new ParseDate(i));
由于SimpleDateFormat并不线程安全的，所以上述代码是错误的使用。最简单的方式就是，自己定义一个类去用synchronized包装（类似于Collections.synchronizedMap）。这样做在高并发时会有问题，对 synchronized的争用导致每一次只能进去一个线程，并发量很低。
这里使用ThreadLocal去封装SimpleDateFormat就解决了这个问题
import java.text.ParseE
import java.text.SimpleDateF
import java.util.D
import java.util.concurrent.ExecutorS
import java.util.concurrent.E
public class Test {
static ThreadLocal&SimpleDateFormat& tl = new ThreadLocal&SimpleDateFormat&();
public static class ParseDate implements Runnable {
int i = 0;
public ParseDate(int i) {
public void run() {
if (tl.get() == null) {
tl.set(new SimpleDateFormat(&yyyy-MM-dd HH:mm:ss&));
Date t = tl.get().parse(& 17:00:& + i % 60);
System.out.println(i + &:& + t);
} catch (ParseException e) {
e.printStackTrace();
public static void main(String[] args) {
ExecutorService es = Executors.newFixedThreadPool(10);
for (int i = 0; i & 1000; i++) {
es.execute(new ParseDate(i));
每个线程在运行时，会判断是否当前线程有SimpleDateFormat对象
if (tl.get() == null)
如果没有的话，就new个 SimpleDateFormat与当前线程绑定
tl.set(new SimpleDateFormat(&yyyy-MM-dd HH:mm:ss&));
然后用当前线程的 SimpleDateFormat去解析
tl.get().parse(& 17:00:& + i % 60);
一开始的代码中，只有一个 SimpleDateFormat，使用了 ThreadLocal，为每一个线程都new了一个SimpleDateFormat。
需要注意的是，这里不要把公共的一个SimpleDateFormat设置给每一个ThreadLocal，这样是没用的。需要给每一个都new一个SimpleDateFormat。
在hibernate中，对ThreadLocal有典型的应用。
下面来看一下ThreadLocal的源码实现
首先Thread类中有一个成员变量：
ThreadLocal.ThreadLocalMap threadLocals =
而这个Map就是ThreadLocal的实现关键
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
createMap(t, value);
根据 ThreadLocal可以set和get相对应的value。
这里的ThreadLocalMap实现和HashMap差不多，但是在hash冲突的处理上有区别。
ThreadLocalMap中发生hash冲突时，不是像HashMap这样用链表来解决冲突，而是是将索引++，放到下一个索引处来解决冲突。
我是没觉得你这样改让代码变得优雅了
花溪的小石头
关于ImportNew
ImportNew 专注于 Java 技术分享。于日 11:11正式上线。是的，这是一个很特别的时刻 :)
ImportNew 由两个 Java 关键字 import 和 new 组成，意指：Java 开发者学习新知识的网站。 import 可认为是学习和吸收， new 则可认为是新知识、新技术圈子和新朋友……
新浪微博：
推荐微信号
反馈建议：@
广告与商务合作QQ：
– 好的话题、有启发的回复、值得信赖的圈子
– 写了文章？看干货？去头条！
– 为IT单身男女服务的征婚传播平台
– 优秀的工具资源导航
– 活跃 & 专业的翻译小组
– 国内外的精选博客文章
– UI,网页，交互和用户体验
– JavaScript, HTML5, CSS
– 专注Android技术分享
– 专注iOS技术分享
– 专注Java技术分享
– 专注Python技术分享
& 2017 ImportNew“钥匙和锁的故事”之启示 - 简书
“钥匙和锁的故事”之启示
图片来自网络
故事是这样的：一日，锁对钥匙埋怨道：“我每天辛辛苦苦为主人看守家门，而主人喜欢的却是你，总是每天把你带在身边。”　而钥匙也不满地说：“你每天待在家里，舒舒服服的，多安逸啊！我每天跟着主人，日晒雨淋的，多辛苦啊！”　一次，钥匙也想过一过锁那种安逸的生活，于是把自己偷偷藏了起来。主人出门后回家，不见了开锁的钥匙，气急之下，把锁给砸了，并把锁扔进了垃圾堆里。主人进屋后，找到了那把钥匙，气愤地说：“锁也砸了，现在留着你还有什么用呢？”说完，把钥匙也扔进了垃圾堆里。 在垃圾堆里相遇的锁和钥匙，不由感叹起来：“今天我们落得如此可悲的下场，都是因为过去我们在各自的岗位上，不是相互配合，而是相互妒忌和猜疑啊！”　故事的结局很发人深省，其实在我们工作中所表现出来也是一样的，公司中的每个岗位、每个环节其实都有自己的不同的工作职责，并且每个岗位的工作任务不一样，工作重心不一样。但每个部门，每个岗位都是一环扣一环的，少了哪一环都不行。犹如机器一样，各零部件装配合理才能运转正常。可是有时候总有些人羡慕别人的岗位，觉得别人比我轻松，比我自由，心理落差就大了。于是抱怨、不信任、互相指责、事事刁难不配合等等接二连三的产生了。如果不良情绪没能及时控制住，长此以往双方离心离德，工作也就没法开展了。最后影响的是整个团体，进而影响到每一个相关的人。很多时候，人与人之间的关系都是相互的，互相扯皮、争斗，只能是两败俱伤，唯有互相配合，团队协作，方能共同繁荣。
图片来自网络
一个人的成功不叫成功，团队的成功才是成功。“木桶理论”中所说的，每个人都是其中木桶的一块板，能盛多少水取决的是那块短的木板，如何才能盛下更多的水，那就需要取长补短，互相包容，互相配合，只有提升短板、帮助短板才能提高整个团队的的“蓄水力”。有些人号称自己能力有多强，多么能干，这也许不可否认你个人的工作能力。但你所做的、所说的，有助于提升团队整体的战斗力么？有助于加强团队的凝聚力么？有助于提高团队的自主性么？也许你做的越多，说的越多反而更大程度上打击了团队的积极性，伤害了了团队的创造力。你说你的成绩还能给团队“+”分么？“无为而治”，不是不为，而是不乱为，是顺势而为。管理的最高境界其实就是“无为而治”。《易经》乾卦中的“用九，见群龙无首，吉”。其意思是一群“龙”在一起各尽所能，团结互助，忠心不二，积极主动，何须“首”的出现？故曰“吉”！这不与“无为而至”不谋而和么。放下自私，放下比较，自主、自发的以团队利益为己任，这才是一只优秀团队真正的内涵所在。人在一起叫团伙，心在一体叫团队。子曰：“君子和而不同，小人同而不和。”抛弃自私，互帮互助，每个人所想的，所做的都是为整个团队好，不抱怨，不埋怨，力往一处使，这才是团队；团队内部之间如果互不信任、互相指责、钩心斗角、山头林立、斤斤计较、自私自利，遇到任何事都往后退。弃团队整体利益而不顾，不闻不问。名义上是团队，其实也不过是团伙罢了。其实比打家劫舍的山贼也好不多到哪去，也许山贼还有“道义”在。唯有包容，方成大器。一个人成就多大，看他自己的胸怀有多大；一个团队成就有多大，那就看它包容有多大。“竹密不妨流水过，山高岂碍白云飞。”唯有包容，才能成就团队。才能成就个人。世上没有一个人的成功是不需要配合，不需要陪伴的。所有的成功的背后，其实都会有一个强大的团队。连科学家牛顿自己也说“自己是站在巨人的肩膀上的”，何况名不见经传的我们。唯有放弃嫉妒，抛弃偏见，同心齐力，方成大器。
诸恶莫作，众善奉行&br&
微信号：level1103 &br&（转载请联系作者，并请注明作者出处）