并发模型之——共享内存模型（线程与锁）理论篇_Java教程_动态网站制作指南
并发模型之——共享内存模型（线程与锁）理论篇
来源：人气：593
并发模型之——共享内存模型（线程与锁）理论篇
这里我们使用的线程与锁来解析共享内存模型；做过java开发并且了解线程安全问题的知道，要使某段代码是线程安全的那必须要满足两个条件：内存可见性、原子性； 内存可见性
在JVM规定多个线程进行通讯是通过共享变量进行的，而Java内存模型规定了有主内存是所有线程共享的，而各个线程又有自己的工作内存，线程只能访问自己的工作内存中数据；
如：有一个共享变量x，两个线程a、b变量x存储在主内存中然后又两个x的拷贝分别存储在a、b线程的工作内存中线程a、b只能对自己工作内存中的x的拷贝进行操作，不可直接操作主内存；
线程a对x修改时先把值放到自己的工作内存中，然后再把工作内存中的x拷贝更新到主内存中，线程b同样如此；当线程a更新了主内存后线程b刷新工作内存后就能看到a更新后的最新值这就是内存可见性问题；
内存可见性要保证两点：1、线程修改后的共享变量更新到主内存；2、从主内存中更新最新值到工作内存中；
内存可见性：线程对共享变量的修改其他线程可以看到修改后的值； 原子性
当线程引用共享变量时，工作内存中没有共享变量时它会从主内存复制共享变量到自己工作内存中，当工作内存有共享变量时线程可能会从主内存更新也有可能直接使用工作内存中的共享变量；有代码块,count为共享变量： 1 ++ // count初始值为0，这时有a、b线程都执行这行代码，可能有不少人以为线程a , b执行完成后count的值为2，但真实情况是count最终值可能为1也可能为2，因为这里有一个原子性问题；
熟悉Java的都知道在Java中++count非原子操作，流程为：
1、把主内存共享变量count拷贝到工作内存
2、把工作内存中count值+1
3、把结果写回更新回主内存
当只有一个线程时这个操作没有问题；
当有多个线程时有可能出现：
1、线程a把主内存共享变量count拷贝到工作内存
2、线程b把主内存共享变量count拷贝到工作内存
3、线程a把工作内存中count进行+1
4、线程b把工作内存中count进行+1
5、线程a把工作内存更新到主内存
6、线程b把工作内存更新到主内存
a,b线程执行完后最终count的值只是1而不是我们期望得到的2，因为这里出现了多个线程交叉执行导致破坏了程序的有序性，而且count+1操作又不是原子的，所以我们必须要保证这程序的原子性，可以使用Java中的synchronized（同步）或Lock机制来解决；
使用共享内存模型进行并发编程时必须要解决我们上面介绍的两个点：内存可见性、原子性，但现在大部分编程语言原生都支持共享内存模型方式的并发所以我们很容易就可以达到这两个要求；
现在代码的执行要经过多层的优化对指令重排序，如：编译器、处理器等级别的优化，经过这些优化重排序后最终代码执行顺序可能与之前是不一致的，在单线程时中编译器、处理会保持as-if-serial，对不存在数据依赖的进行重排序，所以不会出现重排序问题；但在多线程情况下就会出现问题，不过还好Java中有些机制可以使程序在编译器、处理器优化时会对有数据依赖的禁止指令重排序，如：volatile、synchronized等，所以我们可以很轻松应对这问题；
指令重排序问题
在Java中我们要使代码在多线程中同时满足内存可见性与有序性那就要使用Java提供给我们的同步与锁机制如：synchronized、volatile、Lock、concurrent类等；
优点：共享内存模型（线程与锁）可以说是最常见的并发模型大多数编程语言都原生支持，也适合解决很多问题，通过线程与锁实现起来相对也简单点；
缺点：通过多线程实现并发，而线程耗费的资源比较多，线程总数有限制；通过共享内存来实现多线程通讯又会涉及到锁、竟态、死锁等问题影响程序性能；一不小心就会陷入可见性问题、重排序问题等而且多线程程序不容易测试、维护等；文章首发地址：Solinxhttp://www.solinx.co/archives/179
优质网站模板[开源]文件内存映射(即进程间共享内存)|易语言俱乐部 - 易语言俱乐部 - Powered by phpwind
查看完整版本: [--
[开源]文件内存映射(即进程间共享内存)
文件内存映射操作，就是虚拟内存操作:CreateFileMapping...............包括读和写。支持多进程的内存共享源代码在5楼。。。。。。[此贴子已经被作者于 22:50:22编辑过]
创建文件内存映射说白了就是把文件放到虚拟内存中，然后可以关闭真实文件，以后可以直接操作虚拟内存中的文件，而且虚拟内存中的文件和物理文件(真实文件)是关联的(用MapViewOfFile)，可以进行任何操作(如FlushViewOfFile进行写操作)，好处不用说了吧。[此贴子已经被作者于 15:42:34编辑过]
.参数 lpFileMappingAttributes, 整数型, , 安全设置，0是整数型吗？这个类型有问题，它是　安全性结构_　还要把传址选中.可是安全性结构_对应易中的哪个类型呢?不懂.
已经解决。。。打开文件不能用E的打开文件()，要用API:CreateFile
[attachment=68874]源代码发上来了。。包括读和写。支持多进程的内存共享。。。。。。。。[此贴子已经被作者于 22:20:39编辑过]
又学了一招.谢谢了[em02]
又学了一招.谢谢了
谢谢楼主。
学习!&[em05]
学习……………………………………
学习这个API了。~~~~~
頂上　　　　
学习了!支持开源!
先顶后下!!!!!!!!!!!!
做成了类模块,方便大家使用,并作了小小改进[attachment=68912][此贴子已经被作者于 15:34:47编辑过]
以下是引用ye151在 15:33:00的发言：做成了类模块,方便大家使用,并作了小小改进[attachment=68912]支持!
xiexiel& ``````
读不出来了 fffff
做成了类模块,方便大家使用,并作了小小改进&这个能读出
学到知识...
****收藏****
反复学习。。。。。。。。。。。。。。。。
好东东，顶上去！！[em01]
再顶上去[em01]
楼主能否发一个读入外部文件到内存的例子学习，谢谢！[em01]
。。。。。。。。。都已经说过了，先用：&hFile ＝ CreateFileA()打开文件后， 例子中的CreateFileMappingA() 的第一个参数不要用-1，改用hFile就变成载入文件了。其他相关的参数需要去网上搜索这种方法能打开/修改很大的文件。就算几十G也可以的哦。设置偏移.[此贴子已经被作者于 15:32:39编辑过]
设置偏移?楼主能否写个读入外部文件到内存的例子学习学习，谢谢 ！[em01]
.版本 2.子程序 _按钮5_被单击.局部变量 共享内存类, 共享内存类.局部变量 u, 整数型共享内存类.写 (编辑框3.内容, 图片框2.图片)会自关了,难道 太长了?
用户被禁言,该主题自动屏蔽!
模块源代码+例子在这里[此贴子已经被作者于 9:48:53编辑过]
谢谢楼主。
又学了一招.谢谢了！[此贴子已经被作者于 15:16:29编辑过]
谢谢还可以下载啊
这个强，学习了！！！！！！！！谢谢楼主
这个比酒桶的更实用。
[BR]这正是我要找的，感谢LZ
咪咪，顶楼主，真厉害啊
查看完整版本: [--
Powered by
Gzip enabled&|&&|&&|&&|&&
当前位置： >
PostgreSQL 后台进程对共享内存的指针
作者：互联网 & 来源：转载 &
摘要: 开始
InitShmemIndex() --- set up or attach to shmem index table.
InitShmemIndex(void)
InitShmemIndex() --- set up or attach to shmem index table.
InitShmemIndex(void)
* Create the shared memory shmem index.
* Since ShmemInitHash calls ShmemInitStruct, which expects the ShmemIndex
* hashtable to exist already, we have a bit of a circularity problem in
* initializing the ShmemIndex itself.
The special &ShmemIndex& hash
* table name will tell ShmemInitStruct to fake it.
info.keysize = SHMEM_INDEX_KEYSIZE;
info.entrysize = sizeof(ShmemIndexEnt);
hash_flags = HASH_ELEM;
ShmemIndex = ShmemInitHash(&ShmemIndex&,
SHMEM_INDEX_SIZE, SHMEM_INDEX_SIZE,
&info, hash_flags);
其实 ShmemIndex 就是对共享内存的指针：
* ShmemInitHash -- Create and initialize, or attach to, a
shared memory hash table.
* We assume caller is doing some kind of synchronization
* so that two processes don't try to create/initialize the same
* table at once.
(In practice, all creations are done in the postmaster
* child processes should always be attaching to existing tables.)
* max_size is the estimated maximum number of hashtable entries.
* not a hard limit, but the access efficiency will degrade if it is
* exceeded substantially (since it's used to compute directory size and
* the hash table buckets will get overfull).
* init_size is the number of hashtable entries to preallocate.
For a table
* whose maximum size is certain, this should be equal to max_ that
* ensures that no run-time out-of-shared-memory failures can occur.
* Note: before Postgres 9.0, this function returned NULL for some failure
Now, it always throws error instead, so callers need not check
* for NULL.
ShmemInitHash(const char *name, /* table string name for shmem index */
long init_size,
/* initial table size */
long max_size,
/* max size of the table */
HASHCTL *infoP,
/* info about key and bucket size */
int hash_flags)
/* info about infoP */
* Hash tables allocated in shared memory ha it can't
* grow or other backends wouldn't be able to find it. So, make sure we
* make it big enough to start with.
* The shared memory allocator must be specified too.
infoP-&dsize = infoP-&max_dsize = hash_select_dirsize(max_size);
infoP-&alloc = ShmemA
hash_flags |= HASH_SHARED_MEM | HASH_ALLOC | HASH_DIRSIZE;
/* look it up in the shmem index */
location = ShmemInitStruct(name,
hash_get_shared_size(infoP, hash_flags),
* if it already exists, attach to it rather than allocate and initialize
* new space
if (found)
hash_flags |= HASH_ATTACH;
/* Pass location of hashtable header to hash_create */
infoP-&hctl = (HASHHDR *)
return hash_create(name, init_size, infoP, hash_flags);
看hash_create 的相关代码：
* hash_create -- create a new dynamic hash table
tabname: a name for the table (for debugging purposes)
nelem: maximum number of elements expected
*info: additional table parameters, as indicated by flags
flags: bitmask indicating which parameters to take from *info
* Note: for a shared-memory hashtable, nelem needs to be a pretty good
* estimate, since we can't expand the table on the fly.
But an unshared
* hashtable can be expanded on-the-fly, so it's better for nelem to be
* on the small side and let the table grow if it's exceeded.
* large nelem will penalize hash_seq_search speed without buying much.
hash_create(const char *tabname, long nelem, HASHCTL *info, int flags)
* For shared hash tables, we have a local hash header (HTAB struct) that
* we allocate in TopMemoryC all else is in shared memory.
* For non-shared hash tables, everything including the hash header is in
* a memory context created specially for the hash table --- this makes
* hash_destroy very simple.
The memory context is made a child of either
* a context specified by the caller, or TopMemoryContext if nothing is
* specified.
if (flags & HASH_SHARED_MEM)
/* Set up to allocate the hash header */
CurrentDynaHashCxt = TopMemoryC
/* Create the hash table's private memory context */
if (flags & HASH_CONTEXT)
CurrentDynaHashCxt = info-&
CurrentDynaHashCxt = TopMemoryC
CurrentDynaHashCxt = AllocSetContextCreate(CurrentDynaHashCxt,
ALLOCSET_DEFAULT_MINSIZE,
ALLOCSET_DEFAULT_INITSIZE,
ALLOCSET_DEFAULT_MAXSIZE);
/* Initialize the hash header, plus a copy of the table name */
hashp = (HTAB *) DynaHashAlloc(sizeof(HTAB) + strlen(tabname) +1);
MemSet(hashp, 0, sizeof(HTAB));
hashp-&tabname = (char *) (hashp + 1);
strcpy(hashp-&tabname, tabname);
if (flags & HASH_SHARED_MEM)
* ctl structure and directory are preallocated for shared memory
Note that HASH_DIRSIZE and HASH_ALLOC had better be set as
hashp-&hctl = info-&
hashp-&dir = (HASHSEGMENT *) (((char *) info-&hctl) + sizeof(HASHHDR));
hashp-&hcxt = NULL;
hashp-&isshared = true;
/* hash table already exists, we're just attaching to it */
if (flags & HASH_ATTACH)
/* make local copies of some heavily-used values */
hctl = hashp-&
hashp-&keysize = hctl-&
hashp-&ssize = hctl-&
hashp-&sshift = hctl-&
if (!hashp-&hctl)
hashp-&hctl = (HASHHDR *) hashp-&alloc(sizeof(HASHHDR));
if (!hashp-&hctl)
ereport(ERROR,
(errcode(ERRCODE_OUT_OF_MEMORY),
errmsg(&out of memory&)));
if (flags & HASH_FIXED_SIZE)
hashp-&isfixed = true;
在 src/backend/storage/ipc/shmem.c&的注释中也是这么说的：
/* * POSTGRES processes share one or more regions of shared memory. * The shared memory is created by a postmaster and is inherited * by each backend via fork() (or, in some ports, via other OS-specific * methods). The routines in this file are used for allocating and * binding to shared memory data structures.
static HTAB *ShmemIndex = NULL; /* primary index hashtable for shmem */
[作者：技术者高健@博客园 &mail:&&]
版权所有 IT知识库 CopyRight (C)
IT知识库 IT610.com , All Rights Reserved.you have been blocked一、进程与线程？并行与并发？
进程代表一个运行中的程序，是资源分配与调度的基本单位。进程有三大特性：
1、独立性：独立的资源，私有的地址空间，进程间互不影响。
2、动态性：进程具有生命周期。
3、并发性：多进程可以在单核CPU上并发运行。
线程代表进程中的一个顺序执行流，多线程就是一个进程中的多个顺序执行流。线程也被称为轻量级的进程，是系统运行的基本单位。
多线程的优势（进程线程区别）：
1、进程之间不能共享内存，线程之间共享内存更容易，多线程可协作完成进程工作；
2、创建进程进行资源分配的代价较创建线程要大得多，所以多线程在高并发环境中效率更高。
并行与并发：
并行是指：多核多CPU或多机器处理同一段处理逻辑的时候，同一时刻多个执行流共同执行。
并发是指：通过CPU的调度算法，使用户感觉像是同时处理多个任务，但同一时刻只有一个执行流占用CPU执行。即使多核多CPU环境还是会使用并发，以提高处理效率。
主要的CPU调度算法有如下两种：
1、分时调度：每个线程轮流获取CPU使用权，各个线程平均CPU时间片。
2、抢占式调度：Java虚拟机使用的就是这种调度模型。这种调度方式会根据线程优先级，先调度优先级高的线程，如果线程优先级相同，会随机选取线程执行。
二、PCB是什么？
进程控制块，是进程最重要的数据结构，记录着进程的标识、调度信息、控制信息、以及处理机状态。PCB会在进程创建时创建、进程消亡时消亡，伴随PCB整个生命周期。
其中需要了解的有以下几点：
1、进程标识符用于唯一的标识一个进程。一个进程通常有两种标识符：内部标识符和外部标识符。
2、处理机状态信息主要是由处理机的各种寄存器中的内容组成的。处理机在运行中，许多信息都是放在寄存器中的。当处理机被中断时，所有的这些信息都保存在PCB中，以便在该进程重新执行时，能从断点继续执行。
3、进程调度信息包括进程状态、进程优先级、进程调度所需的其他信息，事件（阻塞原因）。
4、进程控制信息包括程序和数据的地址、进程同步和通信机制、资源清单、链接指针。
5、进程控制块的组织方式为链接方式、索引方式。
三、Java创建线程的四种方式？
1、继承Thread类，实现run()方法。
2、实现Runnable接口，实现run()方法。Runnable实例对象作为Thread构造方法中的target参数传入，充当线程执行体。这种方式适用于多个线程共享资源的情况。
3、实现Callable&Class&接口，实现call()方法。
call()方法与run()方法的两个主要区别：
1、call()方法可以有返回值，且返回值类型需要与声明接口时的泛型类型一致。
2、call()方法可以抛出异常。
使用这种方式，步骤较前两种方式比较复杂：
1、在声明接口时就需要指定泛型类型，且call()方法的返回值类型要与泛型类型一致。
2、使用FutureTask&Class&封装Callable实例对象，作为Thread构造方法中的target参数传入。
3、在调用start()后，可使用FutureTask的get()方法获取返回值。
4、实现java.util.concurrent.ThreadFactory接口，实现newThread(Runnable r)方法，自定义创建细节。
四、Java终止线程的四种方式？（可参看博客）
1、自然终止，run()方法执行结束后，线程自动终止。
2、使用stop()方法，已经被弃用。
3、使用volatile 标志位（其实就是外部控制的自然死亡）。
4、使用interrupt()方法中断运行态和阻塞态线程。（关于interrupt()，调用interrupt()方法，立刻改变的是中断状态，但如果不是在阻塞态，就不会抛出异常；如果在进入阻塞态后，中断状态为已中断，就会立刻抛出异常。但是在获取synchronized锁的过程中不可被中断。详解可参看：）
注意：当线程抛出一个未被捕获的异常或错误时，线程会异常终止。
五、sleep()方法与wait()方法区别是什么？wait()方法为什么属于Object类？
它们的都是使线程“等待”一段时间，但是：
sleep()方法是Thread类下的方法，控制线程休眠，休眠过程中不会释放锁，sleep()时间到后进入就绪态等待调度。
wait()方法是Object类下的方法，控制线程等待，等待过程会释放锁，被notify()后会进入就绪态等待调度。
至于wait()方法为什么属于Object类，而不是Thread类，是因为：
wait()方法用于多个线程争用一把锁（一般为Synchronized锁住的对象）的情况，同一时刻只有一个线程能够获得锁，其他线程就要在线程队列等待。作用对象就是被锁住的对象，所以线程队列的维护工作应该交给Object。如果交给Thread，那么每个Thread都要知道其他Thread的状态，这并不合理。
六、start()方法与run()方法区别？
start()方法用于启动线程，会把线程状态由新建态转为就绪态，为线程分配线程私有的方法栈、程序计数器等资源，而start()方法会自动把run()方法作为线程执行体。
run()方法本身与普通方法并无二致，直接调用run()方法不会具有线程的意义。
七、简述线程的生命周期
1、新建态，通过上述几种方式创建了具有线程执行体的Thread对象，就进入了新建态。
2、就绪态，调用Thread对象的start()方法，就会为线程分配线程私有的方法栈、程序计数器资源，如果得到CPU资源，线程就会由就绪态转为运行态。换句话说，就绪态的线程获得了除CPU之外的所有必须资源。
3、运行态，就绪态线程得到CPU资源就会转为运行态，执行run()方法。当然，在调用yield()线程让步的情况，线程会由运行态转到就绪态，但这个过程可能是及其短暂的，如果当前线程拥有较高的优先级，即使让步后，它也会直接转为运行态。
4、阻塞态，会导致阻塞态的方法主要有：sleep()方法、wait()方法、join()方法、等待获取锁、等待IO等情况。在这些情况被处理后，就会转为就绪态，等待调度。
5、终止态，包括第四个问题所说的几种情况。
八、后台线程是什么？有什么应用？
后台线程如其名，就是在后台工作的线程，它的任务是为其他线程提供服务，也叫做“守护线程”与“精灵线程”。通过在start()方法调用前，调用setDeamon(true)方法，将线程设置为后台线程。后台线程会在前台线程死亡后由JVM通知死亡。
后台线程最大的应用就是垃圾回收线程，它是一个典型的后台线程。
九、Java常见的锁类型有哪些？请简述其特点。
1、synchronized对象同步锁：synchronized是对对象加锁，可作用于对象、方法（相当于对this对象加锁）、静态方法（相当于对Class实例对象加锁，锁住的该类的所有对象）以保证并发环境的线程安全。同一时刻只有一个线程可以获得锁。
其底层实现是通过使用对象监视器Monitor，每个对象都有一个监视器，当线程试图获取Synchronized锁定的对象时，就会去请求对象监视器（Monitor.Enter()方法），如果监视器空闲，则请求成功，会获取执行锁定代码的权利；如果监视器已被其他线程持有，线程进入同步队列等待。
2、Lock同步锁：与synchronized功能类似，可从Lock与synchronized区别进行分析：
1、Lock可以通过tryLock()方法非阻塞地获取锁而。如果获取了锁即立刻返回true，否则立刻返回false。这个方法还有加上定时等待的重载方法tryLock(long time, TimeUnit unit)方法，在定时期间内，如果获取了锁立刻返回true，否则在定时结束后返回false。在定时等待期间可以被中断，抛出InterruptException异常。而Synchronized在获得锁的过程中是不可被中断的。
2、Lock可以通过lockInterrupt()方法可中断的获取锁，与lock()方法不同的是等待时可以响应中断，抛出InterruptException异常。
3、Synchronized是隐式的加锁解锁，而Lock必须显示的加锁解锁，而且解锁应放到finnally中，保证一定会被解锁，而Synchronized在出现异常时也会自动解锁。但也因为这样，Lock更加灵活。
4、Synchronized是JVM层面上的设计，对对象加锁，基于对象监视器。Lock是代码实现的。
3、可重入锁：ReentrantLock与Synchronized都是可重入锁。可重入意味着，获得锁的线程可递归的再次获取锁。当所有锁释放后，其他线程才可以获取锁。
4、公平锁与非公平锁：“公平性”是指是否等待最久的线程就会获得资源。如果获得锁的顺序是顺序的，那么就是公平的。不公平锁一般效率高于公平锁。ReentrantLock可以通过构造函数参数控制锁是否公平。
5、ReentrantReadWriteLock读写锁：是一种非排它锁， 一般的锁都是排他锁，就是同一时刻只有一个线程可以访问，比如Synchronized和Lock。读写锁就多个线程可以同时获取读锁读资源，当有写操作的时候，获取写锁，写操作之后的读写操作都将被阻塞，直到写锁释放。读写锁适合写操作较多的场景，效率较高。
6、乐观锁与悲观锁：在Java中的实际应用类并不多，大多用在数据库锁上，可参看：
7、死锁：是当两个线程互相等待获取对方的对象监视器时就会发生死锁。一旦出现死锁，整个程序既不会出现异常也不会有提示，但所有线程都处于阻塞状态。死锁一般出现于多个同步监视器的情况。
十、volatile与automicInteger是什么？如何使用？
在并发环境中有三个因素需要慎重考量，原子性、可见性、有序性。
volatile主要用于解决可见性，它修饰变量，相当于对当前语句前后加上了“内存栅栏”。使当前代码之前的代码不会被重排到当前代码之后，当前代码之后的指令不会被重排到当前代码之前，一定程度保证了有序性。而volatile最主要的作用是使修改volatile修饰的变量值时会使所有线程中的缓存失效，并强制写入公共主存，保证了各个线程的一致。可以看做是轻量级的Synchronized。详情可参看：。
automicXXX主要用于解决原子性，有一个很经典的问题：i++是原子性的操作码？答案是不是，它其实是两步操作，一步是取i的值，一步是++。在取值之后如果有另外的线程去修改这个值，那么当前线程的i值就是旧数据，会影响最后的运算结果。使用automicXXX就可以非阻塞、保证原子性的对数据进行增减操作。详情可参看：
注：在此列举的只是Java多线程最基础的知识，也是面试官最常问到的，先打牢基础，再去探讨底层原理或者高级用法，除了这十个问题，在此再推荐一些其他的资料：
JVM底层又是如何实现synchronized的：
Java线程池详解：
Java线程池深度解析：
ConcurrentHashMap原理分析：
Java阻塞队列详解：
Java多线程常用面试题(含答案,精心总结整理)
Java并发编程问题是面试过程中很容易遇到的问题，提前准备是解决问题的最好办法，将试题总结起来，时常查看会有奇效。
现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执...
1 那些年遇到过的面试题 - 40个多线程问题总结
面试中经常碰到的多线程问题。
JAVA高并发多线程必须懂的50个问题
http://www.importnew.com/12773.html
首页所有文章资讯Web架构基础技术书籍教程Java小组工具资源
Java线程面试题 Top 50
多线程常见问题及分析
1、多线程的并发性和多线程介绍：在过去单CPU时代，单任务在一个时间点只能执行单一程序。之后发展到多任务阶段，计算机能在同一时间点并行执行多任务或多进程。虽然并不是真正意义上的“同一时间点”，而是多个...
多线程弊端及解决办法
多线程的弊端
共享数据错误
当多个线程共享数据，且共享区有两条以上代码时，线程切换可能发生在共享区，这时很容易引起数据错误
简单的比方就是本来是一批资源被多个人使用，本来应该是一个人使用结束后再下个...
1.多线程的引入
什么是线程
* 线程是程序执行的一条路径, 一个进程中可以包含多条线程
* 多线程并发执行可以提高程序的效率, 可以同时完成多项工作
(假如我们电脑同时做着几件事:qq,...
数据争用忘记同步粒度错误读写撕裂无锁定重新排序重新进入死锁锁保护戳记两步舞曲优先级反转实现安全性的模式不变性纯度隔离 数据争用
并发现象无处不在。服务器端程序长久以来都必须负责处理基本并发编程模型，而...
Java程序员金三银四求职季，这些多线程面试题你会吗？
多线程是Java技术面试中面试官比较喜欢问的问题之一。在这里，从面试的角度列出了大部分重要的问题，但是作为一个程序员仍然应该牢固的掌握Java多线程基础知识来对应日后碰到的问题。1. 进程和线程之间有...
java线程高并发编程
java线程详解及高并发编程庖丁解牛
线程概述：
说起java高并发编程，就不得不提起一位老先生Doug Lea,这位老先生可不得了，看看百度百科对他的评价，一点也不为过：
如果IT的...
关于java中多线程的问题的一点思考（什么情况下需要考虑到线程，以及线程安全的问题？）
参与java开发已经有一年左右，算是一个初级的程序员，对于项目中线程的问题有一些自己的看法。同时对于线程而言，是一个比较复杂的问题，在编程中需要着重考虑的地方就是线程的问题。代码中的线程安全问题也是需...
没有更多推荐了，}