精通的Java的程序员大神们，你们谁来给我解释下这个问题？
精通的java的程序员大神们，你们谁来给我解释下这个问题！首先：boolean returnResult =然后在一个地方：returnResult =中间没有线程去改变这个returnResult 的值，returnResult明明值为true，然而断点调试的时候，它就非得要走进else里面去，我感觉对Java不会再爱了，我的三观都毁了！哪个大神能给我解释下这是为什么，没人给我解释的话，我就辞职回家喂猪了！
去搜狐新闻(资讯版)参与此竞猜
搜狐新闻资讯版
给你发了一个红包
下载搜狐新闻(资讯版)，领现金红包
每天阅读新闻还能领取现金奖励哦Java 如何开发一个自定义线程池 | 基于实例代码分步讲解 一站式学习Java | how2j.cn
每一个线程的启动和结束都是比较消耗时间和占用资源的。
如果在系统中用到了很多的线程，大量的启动和结束动作会导致系统的性能变卡，响应变慢。
为了解决这个问题，引入线程池这种设计思想。
线程池的模式很像，消费的对象是一个一个的能够运行的任务
本视频是解读性视频，所以希望您已经看过了本知识点的内容，并且编写了相应的代码之后，带着疑问来观看，这样收获才多。 不建议一开始就观看视频
本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器
如果装有迅雷，播放视频呈现直接下载状态，请调整 迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)
走神了？退回10秒
线程池的思路和是很接近的。1. 准备一个任务容器2. 一次性启动10个 消费者线程3. 刚开始任务容器是空的，所以线程都wait在上面。4. 直到一个外部线程往这个任务容器中扔了一个&任务&，就会有一个消费者线程被5. 这个消费者线程取出&任务&，并且执行这个任务，执行完毕后，继续等待下一次任务的到来。6. 如果短时间内，有较多的任务加入，那么就会有多个线程被唤醒，去执行这些任务。在整个过程中，都不需要创建新的线程，而是循环使用这些已经存在的线程
这是一个自定义的线程池，虽然不够完善和健壮，但是已经足以说明线程池的工作原理缓慢的给这个线程池添加任务，会看到有多条线程来执行这些任务。 线程7执行完毕任务后，又回到池子里，下一次任务来的时候，线程7又来执行新的任务。
import java.util.LinkedL
public class ThreadPool {
// 线程池大小
int threadPoolS
// 任务容器
LinkedList&Runnable& tasks = new LinkedList&Runnable&();
// 试图消费任务的线程
public ThreadPool() {
threadPoolSize = 10;
// 启动10个任务消费者线程
synchronized (tasks) {
for (int i = 0; i & threadPoolS i++) {
new TaskConsumeThread(&任务消费者线程 & + i).start();
public void add(Runnable r) {
synchronized (tasks) {
tasks.add(r);
// 唤醒等待的任务消费者线程
tasks.notifyAll();
class TaskConsumeThread extends Thread {
public TaskConsumeThread(String name) {
super(name);
public void run() {
System.out.println(&启动： & + this.getName());
while (true) {
synchronized (tasks) {
while (tasks.isEmpty()) {
tasks.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
task = tasks.removeLast();
// 允许添加任务的线程可以继续添加任务
tasks.notifyAll();
System.out.println(this.getName() + & 获取到任务，并执行&);
task.run();
public class TestThread {
public static void main(String[] args) {
ThreadPool pool = new ThreadPool();
for (int i = 0; i & 5; i++) {
Runnable task = new Runnable() {
public void run() {
//System.out.println(&执行任务&);
//任务可能是打印一句话
//可能是访问文件
//可能是做排序
pool.add(task);
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
创造一个情景，每个任务执行的时间都是1秒刚开始是间隔1秒钟向线程池中添加任务然后间隔时间越来越短，执行任务的线程还没有来得及结束，新的任务又来了。就会观察到线程池里的其他线程被唤醒来执行这些任务
public class TestThread {
public static void main(String[] args) {
ThreadPool pool= new ThreadPool();
int sleep=1000;
while(true){
pool.add(new Runnable(){
public void run() {
//System.out.println(&执行任务&);
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
Thread.sleep(sleep);
sleep = sleep&100?sleep-100:
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
java提供自带的线程池，而不需要自己去开发一个自定义线程池了。线程池类ThreadPoolExecutor在包java.util.concurrent下ThreadPoolExecutor threadPool= new ThreadPoolExecutor(10, 15, 60, TimeUnit.SECONDS, new LinkedBlockingQueue&Runnable&());第一个参数10 表示这个线程池初始化了10个线程在里面工作第二个参数15 表示如果10个线程不够用了，就会自动增加到最多15个线程第三个参数60 结合第四个参数TimeUnit.SECONDS，表示经过60秒，多出来的线程还没有接到活儿，就会回收，最后保持池子里就10个第四个参数TimeUnit.SECONDS 如上第五个参数 new LinkedBlockingQueue() 用来放任务的集合execute方法用于添加新的任务
import java.util.concurrent.LinkedBlockingQ
import java.util.concurrent.ThreadPoolE
import java.util.concurrent.TimeU
public class TestThread {
public static void main(String[] args) throws InterruptedException {
ThreadPoolExecutor threadPool= new ThreadPoolExecutor(10, 15, 60, TimeUnit.SECONDS, new LinkedBlockingQueue&Runnable&());
threadPool.execute(new Runnable(){
public void run() {
// TODO Auto-generated method stub
System.out.println(&任务1&);
&姿势不对,事倍功半!
，如果文件特别多，就会创建很多的线程。 改写这个练习，使用线程池的方式来完成。初始化一个大小是10的线程池遍历所有文件，当遍历到文件是.java的时候，创建一个查找文件的任务，把这个任务扔进线程池去执行，继续遍历下一个文件
在查看答案前，尽量先自己完成，碰到问题再来查看答案，收获会更多
import java.io.F
import java.io.FileR
import java.io.IOE
public class SearchFileTask implements Runnable{
public SearchFileTask(File file,String search) {
this.file =
this.search=
public void run(){
String fileContent = readFileConent(file);
if(fileContent.contains(search)){
System.out.printf( &线程: %s 找到子目标字符串%s,在文件:%s%n&,Thread.currentThread().getName(), search,file);
public String readFileConent(File file){
try (FileReader fr = new FileReader(file)) {
char[] all = new char[(int) file.length()];
fr.read(all);
return new String(all);
} catch (IOException e) {
e.printStackTrace();
import java.util.LinkedL
public class ThreadPool {
// 线程池大小
int threadPoolS
// 任务容器
LinkedList&Runnable& tasks = new LinkedList&Runnable&();
// 试图消费任务的线程
public ThreadPool() {
threadPoolSize = 10;
// 启动10个任务消费者线程
synchronized (tasks) {
for (int i = 0; i & threadPoolS i++) {
new TaskConsumeThread(&任务消费者线程 & + i).start();
public void add(Runnable r) {
synchronized (tasks) {
tasks.add(r);
// 唤醒等待的任务消费者线程
tasks.notifyAll();
class TaskConsumeThread extends Thread {
public TaskConsumeThread(String name) {
super(name);
public void run() {
while (true) {
synchronized (tasks) {
while (tasks.isEmpty()) {
tasks.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
task = tasks.removeLast();
// 允许添加任务的线程可以继续添加任务
tasks.notifyAll();
task.run();
import java.io.F
public class TestThread {
static ThreadPool pool= new ThreadPool();
public static void search(File file, String search) {
if (file.isFile()) {
if(file.getName().toLowerCase().endsWith(&.java&)){
SearchFileTask task = new SearchFileTask(file, search);
pool.add(task);
if (file.isDirectory()) {
File[] fs = file.listFiles();
for (File f : fs) {
search(f, search);
public static void main(String[] args) {
File folder =new File(&e:\\project&);
search(folder,&Magic&);
把你的代码复制到下面区域。 如果在线比较不好用，请使用客户端比较软件：
代码高亮插件双击即可选中，不过部分同学反应，通过代码高亮插件复制的代码无法在IDEA里正常显示，这里提供TEXTAREA的方式，方便复制，谢谢
根据练习目标尽量自己实现代码效果，期间会碰到疑问，难题，和自己不懂的地方，这些都是必要的过程
完成过程中，碰到无法解决的问题，带着疑问，查看答案，分析答案的解决思路
依然有不明白的地方，点开视频讲解，带着疑问，听视频讲解有问题的部分
理解后，再从头做一遍，把有疑问的地方都捋清楚
最后再总结一遍，总结思路，总结解决办法，以后遇到类似的问题，怎么处理
把这时的想法，思路，研究都记录下来，等全部学完了，再回过头来巩固和理解，学习效果就会很好，知识点掌握得也牢固.
HOW2J公众号，关注后实时获知布最新的教程和优惠活动，谢谢。
答案时间：
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
答案时间：
答案时间：
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
zzxssb1997
答案时间：
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
答案时间：
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
答案时间：
答案时间：
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
答案时间：
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
答案时间：
答案时间：
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
答案时间：
答案时间：
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
答案时间：
答案时间：
答案时间：
答案时间：
答案时间：
答案时间：
答案时间：
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
答案时间：
答案时间：
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
答案时间：
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
答案时间：
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
答案时间：
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
答案时间：
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
答案时间：
答案时间：
答案时间：
答案时间：
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
答案时间：
答案时间：
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
答案时间：
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
答案时间：
答案时间：
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
答案时间：
答案时间：
请至少填写一项, 如果是自己有问题，请重新提问，否则站长有可能看不到
提问之前请
欢庆国际儿童节，全场五折，优惠码：HAPPYCHILD
可用于全站通
有效期5.28-5.30应用多个线程同时解析多个文件，比起使用单线程顺序解析这些文件，效率并没有提高 ？？
我这里先是读取远程数据库中的文件，然后在本地解压，最后输出。远程数据库是文件数据库
该问题被发起重新开启投票
投票剩余时间：
之前被关闭原因：
该问题被发起删除投票
投票剩余时间：
距离悬赏到期还有：
参与关闭投票者：
关闭原因：
该问题已经被锁定
锁定原因：（）
保护原因：避免来自新用户不合宜或无意义的致谢、跟帖答案。
该问题已成功删除，仅对您可见，其他人不能够查看。
我感觉你首先应该明白多线程一些作用；使用线程的好处有以下几点：
·使用线程可以把占据长时间的程序中的任务放到后台去处理
·用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度
·程序的运行速度可能加快
·在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下我们可以释放一些珍贵的资源如内存占用等等。
你出现的问题就像上面两位前辈所说的，采用文件操作影响了你的效率，你应该改变一下这种机制，变为现在流行的nosql机制，当然这是我个人的建议
1，多线程主要是为了充分利用多核cpu资源，如果你的硬件跟不上，只有一个cpu，那么多线程从并发变成了串行了，另外再加上线程上下文切换的时候，那你就得不偿失了2，线程的个数对于一个应用程序来讲的话，往往会有一个临界值。3，临界资源的访问问题，程序中临界区的指令一般来说越少越好，最好不要在临界区中做一些重量级的事情，例如说数据库，写文件，读文件！
这个问题很难一句两句说清楚，多线程的使用一定要慎用，使用多个线程来处理多任务的时候，效率肯定是有提高的，要不也不会有多线程这种东西存在了。但是对硬盘的读写有特殊的地方。多线程使用的时候，要注意下面几个几点：1.如果多线程是同步操作一个原子数据，（多个线程同步去处理一个加锁的对象），那效率肯定不会提升，就好像1个人去做1件事和多个人排队去做一件事效率是一样的；2.服务器的硬件问题，多线程跑起来肯定会比单线程跑起来更加费CPU和内存，如果你的硬件本身就不给力，那也肯定快不起来；3.关于多文件的了：对磁盘进行多线程处理的时候，效率会急速下降！！因为不同文件的读写，会造成磁头的频繁转换，磁头的频繁转换要比读取磁盘的时间更长。所以这种情况下，最好有个线程去读取文件，其他的线程去处理文件数据中的业务逻辑处理
你是不是采用普通的 Ｆile文件ＡＰＩ来读写文件？如果你，这种用法是肯定不会提高效率的！因为文件，网络等流的读写都需要操作ＩＯ通道，而操作系统的ＩＯ通道数量是固定的。
我们假设你的电脑只有一个ＩＯ通道，如果你打开一个文件流并进行读写，则占用了一个ＩＯ通道，如果你又打开一个文件流，则第二个文件流需要等待第一个文件关闭通道才能真正意义上的进行读写。 所以实际上，你打开多个文件同时进行读写时就是在串行单线程操作。
解决的办法是采用 NIO: java.nio (Java 2 Platform SE v1.4.2)ＮＩＯ的意思当然就是同时开启Ｎ个ＩＯ通道了，如果你的机器硬件的确只支持同时打开一个通道的话，ＪＡＶＡ虚拟器会帮你做虚拟协调（很强大吧？） ＮＩＯ比普通ＩＯ技术至少快30％，
请看我的示例代码，这段代码是用在Ａndroid客户端的，在普通Java上可能有所不同，具体可以查看ＪＡＣＡ 文件ＮＩＯ的文档
假设需求是：public static void saveFileToLocalDisk(String fileName, byte[] buffer)
则实现应该是：
FileOutputStream os =
FileChannel channel=
ByteBuffer byteBuffer=
os = new FileOutputStream(file);
if(os!=null){
channel=os.getChannel();
byteBuffer=ByteBuffer.allocate(buffer.length);
byteBuffer.put(buffer);
byteBuffer.flip();
channel.write(byteBuffer);
} catch (IOException e) {
e.printStackTrace();
} finally {
if(os!=null){
os.close();
if(channel!=null){
channel.close();
if(byteBuffer!=null){
byteBuffer.clear();
byteBuffer=
}catch(Exception e){}
还记得普通方式写文件吗？先得到FileOutputStream，然后直接设用 os.write(bytes);而现在不同点在于先得到一个Ｃhannel再建构一个Bytebuffer，再用两者完成任务，ＪＡＶＡ虚拟机帮你完成剩下的ＣＰＵ和ＩＯ任务调度
<dd style="float:cursor:" title="声誉值：1K
解析文件，解压这些操作都是耗计算的（耗cpu时间），也就是说任务的快慢取决于cpu和算法的性能。线程是为了解决真正意义上需要并行的不同任务，前提是这些并行任务不是特别耗计算，或者说这些任务任意一个都不能满负荷cpu，这样的线程执行并行任务才有提高效率的可能。
感觉不是效率没有提高，而是使用方法有问题，或者是关乎磁盘的问题了，频繁德磁头转换，如果单个数据不是很大，可以尝试一次性将文件读入内存或者是分几个大部分读入内存，之后在内存中操作，也许会好一些。
读远程文件效率低的由下面几点决定:1、网络环境(网速，远程服务器响应速度)2、系统环境(系统本身配置是否达到最化化，如socket等)3、软件环境(服务器，如jboos tomcat,jvm配置)4、代码本身(最后才是代码本身)
性能没有提升是因为你前面3个没搞好，别怪代码
import java.util.concurrent.ExecutorSimport java.util.concurrent.Epublic class TestThread extends Thread {
public int ThreadId;
public TestThread(int ThreadId) {
this.ThreadId = ThreadId;
public void run() {
// TODO Auto-generated method stub
for (int i = 0; i &= 100; i++)
System.out.println("进程" + ThreadId + ":" + i);
super.run();
public static void main(String[] args) {
// for(int i=0;i&=3;i++)
// new TestThread(i).run();
// TestThread th = new TestThread(i);
// 在线程池中创建3个线程空间
ExecutorService exec = Executors.newFixedThreadPool(3);
// Object TestT
for (int i = 0; i &= 3; i++) {
TestThread th = new TestThread(i);
// 线程池运行
exec.execute(th);
exec.shutdown();
对比一下for(int i=0;i&=3;i++)
new TestThread(i).run();
跟for (int i = 0; i &= 3; i++) {
TestThread th = new TestThread(i);
// 线程池运行
exec.execute(th);
java多线程，你可以理解释缓解主线程的压力，但是线程多了势必会造成一些不良后果，比如线程阻塞等等，可定会影响效率。
我个人的一点想法，多线程虽然是并发，但同样受硬件影响，比如CPU、内存等，而且某些共享的数据加锁后被使用也会阻塞线程，就像木桶原理，取决于最短的木板，好好查查当前或者的线程数和共享的数据有没有什么问题。
java多线程是要消耗cpu的，机器有几个CPU最好创建一个线程，这样的效率是最高的。你的问题需要检查一下，瓶颈是否在线程这里，还是网络链接或者IO这里。
不是您所需，查看更多相关问题与答案
德问是一个专业的编程问答社区，请
后再提交答案
关注该问题的人
共被浏览 (16795) 次当前位置： →
→ eclipse做的java程序,如何在子线程中修改主界面的内容
eclipse做的java程序,如何在子线程中修改主界面的内容
& 作者：佚名 & 来源： 互联网 & 热度：
&收藏到→_→：
摘要: eclipse做的java程序，怎么在子线程中修改主界面的内容？我的程序中，在主线程中调用修改界面文字的代码，可以正常运行。 但是...
"eclipse做的java程序,如何在子线程中修改主界面的内容"：：
eclipse做的java程序，怎么在子线程中修改主界面的内容？我的程序中，在主线程中调用修改界面文字的代码，可以正常运行。
但是，在一个子线程中调用同样的代码，就出错，提示“处理异步线程队列时发生异常”。
java程序该怎么处理跨线程的窗口函数调用呢？ ------解决方案--------------------查一下前面的文章，有类似的,用户线程如何修改界面内容 此文来自: 马开东博客
转载请注明出处 网址：
搜索此文相关文章：此文来自: 马开东博客
网址: 站长QQ
上一篇：没有了
eclipse做的java程序,如何在子线程中修改主界面的内容_J2SE相关文章
J2SE_总排行榜
J2SE_月排行榜
J2SE_周排行榜
J2SE_日排行榜Java 为什么多线程往一个list中放值，但是放值的个数每次都不一样为什么
package app.ThreadA
import java.util.I
import java.util.L
import java.util.M
import java.util.Map.E
public class MyThread extends Thread {
private Map&String, Object& compareM
private List&Object&
public MyThread(Map&String, Object& compareMap,List&Object& list ){
this.compareMap = compareM
this.list=
public void run() {
// System.out.println(“aaaaaaaaaa”);
Iterator&Entry&String, Object&& iterator = compareMap.entrySet().iterator();
while (iterator.hasNext()) {
Entry&String, Object& entry = iterator.next();
if (“20”.equals(entry.getKey())) {
list.add(true);
package app.ThreadA
import java.util.ArrayL
import java.util.HashM
import java.util.I
import java.util.L
import java.util.M
import java.util.Map.E
public class Main {
public static void main(String[] args) {
Map&String, Object& compareMap = new HashMap&String, Object&();
for (int i = 0; i & 100; i++) {
compareMap.put(String.valueOf(i), i);
List&Object& list = new ArrayList&Object&();
long start = System.currentTimeMillis();
for (int i = 0; i & 100; i++) {
Thread thread1=new MyThread(compareMap,list);
thread1.start();
long end = System.currentTimeMillis();
System.out.println((end – start) / 1000.00);
System.out.println(list.size());
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
package app.ThreadApplication;&import java.util.Iterator;import java.util.List;import java.util.Map;import java.util.Map.Entry;&public class MyThread extends Thread {&&&&private Map&String, Object& compareMap;&&&&private List&Object& list;&&&&public MyThread(Map&String, Object& compareMap,List&Object& list ){&&&&&&&&this.compareMap = compareMap;&&&&&&&&this.list=list;&&&&}&&&&public void run() {// System.out.println(“aaaaaaaaaa”);&&&&&&&&Iterator&Entry&String, Object&& iterator = compareMap.entrySet().iterator();&&&&&&&&&while (iterator.hasNext()) {&&&&&&&&&&&&Entry&String, Object& entry = iterator.next();&&&&&&&&&&&&if (“20”.equals(entry.getKey())) {&&&&&&&&&&&&&&&&list.add(true);&&&&&&&&&&&&}&&&&&&&&}&&&&}}&package app.ThreadApplication;&import java.util.ArrayList;import java.util.HashMap;import java.util.Iterator;import java.util.List;import java.util.Map;import java.util.Map.Entry;&public class Main {&&&&&public static void main(String[] args) {&&&&&&&&&Map&String, Object& compareMap = new HashMap&String, Object&();&&&&&&&&for (int i = 0; i & 100; i++) {&&&&&&&&&&&&compareMap.put(String.valueOf(i), i);&&&&&&&&}&&&&&&&&List&Object& list = new ArrayList&Object&();&&&&&&&&&long start = System.currentTimeMillis();&&&&&&&&for (int i = 0; i & 100; i++) {&&&&&&&&&&&&Thread thread1=new MyThread(compareMap,list);&&&&&&&&&&&&thread1.start();&&&&&&&&&}&&&&&&&&&long end = System.currentTimeMillis();&&&&&&&&System.out.println((end – start) / 1000.00);&&&&&&&&System.out.println(list.size());&&&&&}}
java为什么多线程往一个list中放值，但是放值的个数每次都不一样为什么，不太明白，有的人可能怀疑是因为线程没有跑完，
所以我就DEBUG在list.size那句话之前，这样我可能保证线程都跑完在执行那个list.size然而还是有的情况下丢数据，list的大小每次可能不同。
还有有的人说是因为List是线程不安全的，那我就更不明了了，一个进程下的线程应该都是同一个CPU下的，CPU一个时间片其实也就是执行一个线程，这样不也是一个线程一个线程执行么？list数据不也是一个一个往里面追加么？为什么会丢数据？而且我传入的是引用，他们所找的对象内存空间也是同一个呀？是在是不明白求大神解答一下
一个进程下的线程应该都是同一个CPU下的，CPU一个时间片其实也就是执行一个线程
你还没搞懂线程和进程的区别，谁告诉你同一时间下cpu只执行一个线程的?至于为什么会丢数据，你可以想象一下这样一个场景:你有一个账号余500块钱，你往银行存钱，与此同时，有人在异地从你账号里取钱。假设atm机得到你的账户余额，在此余额下加上200，得到一个新的余额700并返回给银行数据中心，另一个人同样提前得到了你账户的余额500，减去两百，atm给银行返回一个余额值300，假设你操作的atm传输速度稍快一点，提前到达，这时候余额是700，但马上，新的信息又把这个数字覆盖为300，那你是不是凭空失去了两百块钱？这就是数据丢失。
关于伯乐小组
这里有好的话题，有启发的回复和值得信任的圈子。
新浪微博：
推荐微信号
（加好友请注明来意）
- 好的话题、有启发的回复、值得信赖的圈子
- 分享和发现有价值的内容与观点
- 为IT单身男女服务的征婚传播平台
- 优秀的工具资源导航
- 翻译传播优秀的外文文章
- 国内外的精选博客文章
- UI,网页，交互和用户体验
- 专注iOS技术分享
- 专注Android技术分享
- JavaScript, HTML5, CSS
- 专注Java技术分享
- 专注Python技术分享
& 2018 伯乐在线}