To publish an object safely, both the reference to the object and the object's state must be made visible to other threads at the same time. A properly constructed object can be safely published by:
Initializing an object reference from a static initializer;
Storing a reference to it into a volatile field or AtomicReference;
Storing a reference to it into a final field of a properly constructed object; or
Storing a reference to it into a field that is properly guarded by a lock (查看原文)
Our goal is to give readers a set of design rules and mental models that make
it easier—and more fun—to build correct, performant concurrent classes and applications
in Java. (查看原文)
Threads are sometimes called lightweight processes, and most modern operating
systems treat threads, not processes, as the basic units of scheduling. (查看原文)
Using multiple threads can also help achieve better throughput on singleprocessor
systems. If a program is single-threaded, the processor remains idle
while it waits for a synchronous I/O operation to complete. In a multithreaded
program, another thread can still run while the first thread is waiting for the I/O
to complete, allowing the application to still make progress during the blocking
I/O. (This is like reading the newspaper while waiting for the water to boil, rather
than waiting for the water to boil before starting to read.) (查看原文)
Historically, operating systems placed relatively low limits on the number of
threads that a process could create, as few as several hundred (or even less).
As a result, operating systems developed efficient facilities for multiplexed I/O,
such as the Unix select and poll system calls, and to access these facilities, the
Java class libraries acquired a set of packages (java.nio) for nonblocking I/O.
However, operating system support for larger numbers of threads has improved
significantly, making the thread-per-client model practical even for large numbers
of clients on some platforms. (查看原文)
Operating systems evolved to aloowed more than one programm to run at once, running individual programs in processes:isolated, independently executing programs to which the operationg system allocates resources such as memory,file handles, and security credentials. If they needed to,processes could communicate with one another through a variety of coarse-grained communicateion mechanisms:sockets,signal handlers,shared memory,semaphores, and files (查看原文)
The same concerns(resources utilization,fairness,and convenience) that motivated the development of progresses also motivated the development of threads. Threads allow multiple streams of program control flow to coexsit within a progress. They share process-wide resources such as memory and file handles, but each thread has its own program counter,stack, and local variables. Threads also provide a natural decomposition for exploiting hardware parallelism on multiprocessor systems; multiple threads within the same program can be scheduled simultaneously on multiple CPUs. (查看原文)
Informally, an object's state is its data, stored in state variables such as instance or static fields. An object's state may include fields from other, dependent objects; a HashMap's state is partially stored in the HashMap object itself, but also in many Map.Entry objects. An object's state encompasses any data that can affect its externally visible behavior. (查看原文)
