在现代的操作系统中,进程是资源分配的最小单位,而线城是CPU调度的基本单位。一个进程中最少有一个线程,名叫主线程。进程是程序执行的一个实例,比如说10个用户同时执行Chrome浏览器,那么就有10个独立的进程(尽管他们共享一个可执行代码)。
每一个进程都有自己的独立的一块内存空间、一组资源系统。其内部数据和状态都是完全独立的。进程的优点是提高CPU的运行效率,在同一个时间内执行多个程序,即并发执行。但是从严格上将,也不是绝对的同一时刻执行多个程序,只不过CPU在执行时通过时间片等调度算法不同进程告诉切换。
所以总结来说:进程由操作系统调度,简单而且稳定,进程之间的隔离性好,一个进程的奔溃不会影响其他进程。单进程编程简单,在多个情况下可以把进程和CPU进行绑定,从分利用CPU。
当然多进程也有一些缺点
一般来说进程消耗的内存比较大,进程切换代价很高,进程切换也像线程一样需要保持上一个进程的上下文环境。比如在Web编程中,如果一个进程处理一个请求的话,如果提高并发量就要提高进程数,而进程数量受内存和切换代价限制。
线程是进程的一个实体,是CPU调度和分配的基本单位,它比进程更下偶读能独立运行的基本单位,线程自己基本上不拥有系统资源,只拥有一点在运行中不可少的资源(如程序计数器、栈),但是它可与同属一个进程的其他线程共享进程所拥有的全部资源。
同类的多线程共享一块内存空间个一组系统资源,线程本身的数据通常只有CPU的寄存器数据,以及一个供程序执行的堆栈。线程在切换时负荷小,因此,线程也称为轻负荷进程。一个进程中可以包含多个线程。
在JVM中,本地方法栈、虚拟机栈和程序计数器是线程隔离的,而堆区和方法区是线程共享的。
地址空间:线程是进程内的一个执行单元;进程至少有一个线程;一个进程内的多线程它们共享进程的地址空间;而进程自己独立的地址空间 资源有用:进程是资源分配和拥有的单位,同一个进程内的线程共享进程的资源。 线程是处理器调度的基本单位,但进程不是 二者均可并发执行(下面补充了并发和并行的区别)
并发:多个事件在同一个时间段内一起执行 并行:多个事件在同一时刻同时执行
为了进一步提高CPU的利用率,多线程便诞生了。一个程序可以运行多个线程,多个线程可以同时执行,从整个应用角度上看,这个应用好像独自拥有多个CPU一样。虽然多线程进一步提高了应用的执行效率,但是由于线程之间会共享内存资源,这会导致一些资源同步的问题,另外,线程之间切换也会对资源有所消耗。
这里需要注意的是,如果一台电脑只有一个CPU核心,那么多线也并没有真正的"同时"运行,它们之间需要通过相互切换来共享CPU核心,所以,只有一个CPU核心的情况下,多线程不会提高应用效率。但是,现在计算机一般都会有多个CPU,并且每个CPU可能还有会多个核心,所以现在硬件资源条件下,多线程编程可以极大的提高应用的效率。
多CPU.png
在Java程序中,JVM负责线程的调度。线程调度是按照特定的机制为多个线程分配CPU的使用权。
调度的模式有两种:分时调度和抢占式调度。分时调度是所有线程轮流获得CPU使用权,并平均分配每个线程占用CPU的时间;抢占式调度是根据线程的优先级别来获取CPU的使用权。JVM的线程调度模式采用了抢占式模式。
Android线程,一般地就是指Android虚拟机线程,而虚拟机线程是由通过系统调用而创建的Linux线程。纯粹的的Linux线程与虚拟机线程区别在于虚拟机线程具有运行Java代码的runtime。
在Android 中当担也就对应一个类。从这一点上看Thread和其他类并没有任何区别,只不过Thread的属性和方法仅用于完成"线程管理"这个任务而已。在Android系统中,我们经常需要启动一个新的线程,这些线程大多从Thread这个类继承
public class Thread implements Runnable {
.....
}
通过上面代码,我们可以知道Thread实现了Runnable,侧面也说明线程是"可执行的代码"。
public interface Runnable {
public abstract void run();
}
Runnable是一个接口类,唯一提供的方法就是run()。
一般情况下,我们是这样使用Thread的:
public MyThread extends Thread{
}
MyThread mt=new MyThread();
mt.start();
Thread的关键就是Runnable,因此下面的是另一个常见的用法。
new Thread(Runnable runnable).start();
Thread常用方法.png
volatile ThreadGroup group;
volatile boolean daemon;
volatile String name;
volatile int priority;
volatile long stackSize;
Runnable target;
private static int count = 0;
/**
* Holds the thread's ID. We simply count upwards, so
* each Thread has a unique ID.
*/
private long id;
/**
* Normal thread local values.
*/
ThreadLocal.Values localValues;
我们就依次说下:
为什么要研究create()方法?因为Thread一种有9个构造函数,其中8个里面最终都是调用了create()方法
在Thread.java 402行
/**
* Initializes a new, existing Thread object with a runnable object,
* the given name and belonging to the ThreadGroup passed as parameter.
* This is the method that the several public constructors delegate their
* work to.
*
* @param group ThreadGroup to which the new Thread will belong
* @param runnable a java.lang.Runnable whose method <code>run</code> will
* be executed by the new Thread
* @param threadName Name for the Thread being created
* @param stackSize Platform dependent stack size
* @throws IllegalThreadStateException if <code>group.destroy()</code> has
* already been done
* @see java.lang.ThreadGroup
* @see java.lang.Runnable
*/
private void create(ThreadGroup group, Runnable runnable, String threadName, long stackSize) {
//步骤一
Thread currentThread = Thread.currentThread();
//步骤二
if (group == null) {
group = currentThread.getThreadGroup();
}
if (group.isDestroyed()) {
throw new IllegalThreadStateException("Group already destroyed");
}
this.group = group;
synchronized (Thread.class) {
id = ++Thread.count;
}
if (threadName == null) {
this.name = "Thread-" + id;
} else {
this.name = threadName;
}
this.target = runnable;
this.stackSize = stackSize;
this.priority = currentThread.getPriority();
this.contextClassLoader = currentThread.contextClassLoader;
// Transfer over InheritableThreadLocals.
if (currentThread.inheritableValues != null) {
inheritableValues = new ThreadLocal.Values(currentThread.inheritableValues);
}
// add ourselves to our ThreadGroup of choice
//步骤二
this.group.addThread(this);
}
我把create内部代码大体上分为3个部分
线程共有6种状态;在某一时刻只能是这6种状态之一。这些状态由Thread.State这个枚举类型表示,并且可以通过getState()方法获得当前具体的状态类型。
Thread.State这个枚举类在在Thread.java 78行
/**
* A representation of a thread's state. A given thread may only be in one
* state at a time.
*/
public enum State {
/**
* The thread has been created, but has never been started.
*/
NEW,
/**
* The thread may be run.
*/
RUNNABLE,
/**
* The thread is blocked and waiting for a lock.
*/
BLOCKED,
/**
* The thread is waiting.
*/
WAITING,
/**
* The thread is waiting for a specified amount of time.
*/
TIMED_WAITING,
/**
* The thread has been terminated.
*/
TERMINATED
}
我们在用说明下:
总结称为一幅图就是下图
Thread的生命周期.png
上面说的这两种方法获取Thread,最终都通过start()方法启动。
代码在Thread.java 1058行
/**
* Starts the new Thread of execution. The <code>run()</code> method of
* the receiver will be called by the receiver Thread itself (and not the
* Thread calling <code>start()</code>).
*
* @throws IllegalThreadStateException - if this thread has already started.
* @see Thread#run
*/
public synchronized void start() {
//保证线程只启动一次
checkNotStarted();
hasBeenStarted = true;
nativeCreate(this, stackSize, daemon);
}
private void checkNotStarted() {
if (hasBeenStarted) {
throw new IllegalThreadStateException("Thread already started");
}
}
通过上面代码我们看到,start()方法里面首先是判断是不是启动过,如果没启动过直接调用nativeCreate(Thread , long, boolean)方法,通过方法名,我们知道是一个nativce方法
代码在Thread.java 1066行
private native static void nativeCreate(Thread t, long stackSize, boolean daemon);
nativeCreate()这是一个native方法,那么其所对应的JNI方法在哪里?在java_lang_Thread.cc中国getMethods是一个JNINativeMethod数据
代码在java_lang_Thread.cc 179行
static JNINativeMethod gMethods[] = {
NATIVE_METHOD(Thread, currentThread, "!()Ljava/lang/Thread;"),
NATIVE_METHOD(Thread, interrupted, "!()Z"),
NATIVE_METHOD(Thread, isInterrupted, "!()Z"),
NATIVE_METHOD(Thread, nativeCreate, "(Ljava/lang/Thread;JZ)V"),
NATIVE_METHOD(Thread, nativeGetStatus, "(Z)I"),
NATIVE_METHOD(Thread, nativeHoldsLock, "(Ljava/lang/Object;)Z"),
NATIVE_METHOD(Thread, nativeInterrupt, "!()V"),
NATIVE_METHOD(Thread, nativeSetName, "(Ljava/lang/String;)V"),
NATIVE_METHOD(Thread, nativeSetPriority, "(I)V"),
NATIVE_METHOD(Thread, sleep, "!(Ljava/lang/Object;JI)V"),
NATIVE_METHOD(Thread, yield, "()V"),
};
其中一项为:
NATIVE_METHOD(Thread, nativeCreate, "(Ljava/lang/Thread;JZ)V"),
这里的NATIVE_METHOD定义在java_lang_Object.cc文件中,如下:
代码在java_lang_Object.cc 25行
#define NATIVE_METHOD(className, functionName, signature, identifier) \
{ #functionName, signature, reinterpret_cast<void*>(className ## _ ## identifier) }
将宏定义展开并带入,可得所对应的方法名为Thread_nativeCreate
代码在java_lang_Thread.cc 49行
static void Thread_nativeCreate(JNIEnv* env, jclass, jobject java_thread, jlong stack_size,
jboolean daemon) {
Thread::CreateNativeThread(env, java_thread, stack_size, daemon == JNI_TRUE);
}
看到 只是调用了Thread类的CreateNativeThread
代码在thread.cc 388行
void Thread::CreateNativeThread(JNIEnv* env, jobject java_peer, size_t stack_size, bool is_daemon) {
CHECK(java_peer != nullptr);
Thread* self = static_cast<JNIEnvExt*>(env)->self;
Runtime* runtime = Runtime::Current();
// Atomically start the birth of the thread ensuring the runtime isn't shutting down.
bool thread_start_during_shutdown = false;
{
MutexLock mu(self, *Locks::runtime_shutdown_lock_);
if (runtime->IsShuttingDownLocked()) {
thread_start_during_shutdown = true;
} else {
runtime->StartThreadBirth();
}
}
if (thread_start_during_shutdown) {
ScopedLocalRef<jclass> error_class(env, env->FindClass("java/lang/InternalError"));
env->ThrowNew(error_class.get(), "Thread starting during runtime shutdown");
return;
}
Thread* child_thread = new Thread(is_daemon);
// Use global JNI ref to hold peer live while child thread starts.
child_thread->tlsPtr_.jpeer = env->NewGlobalRef(java_peer);
stack_size = FixStackSize(stack_size);
// Thread.start is synchronized, so we know that nativePeer is 0, and know that we're not racing to
// assign it.
env->SetLongField(java_peer, WellKnownClasses::java_lang_Thread_nativePeer,
reinterpret_cast<jlong>(child_thread));
// Try to allocate a JNIEnvExt for the thread. We do this here as we might be out of memory and
// do not have a good way to report this on the child's side.
std::unique_ptr<JNIEnvExt> child_jni_env_ext(
JNIEnvExt::Create(child_thread, Runtime::Current()->GetJavaVM()));
int pthread_create_result = 0;
if (child_jni_env_ext.get() != nullptr) {
pthread_t new_pthread;
pthread_attr_t attr;
child_thread->tlsPtr_.tmp_jni_env = child_jni_env_ext.get();
CHECK_PTHREAD_CALL(pthread_attr_init, (&attr), "new thread");
CHECK_PTHREAD_CALL(pthread_attr_setdetachstate, (&attr, PTHREAD_CREATE_DETACHED),
"PTHREAD_CREATE_DETACHED");
CHECK_PTHREAD_CALL(pthread_attr_setstacksize, (&attr, stack_size), stack_size);
/***这里是重点,创建线程***/
pthread_create_result = pthread_create(&new_pthread,
&attr,
Thread::CreateCallback,
child_thread);
CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attr), "new thread");
if (pthread_create_result == 0) {
// pthread_create started the new thread. The child is now responsible for managing the
// JNIEnvExt we created.
// Note: we can't check for tmp_jni_env == nullptr, as that would require synchronization
// between the threads.
child_jni_env_ext.release();
return;
}
}
// Either JNIEnvExt::Create or pthread_create(3) failed, so clean up.
{
MutexLock mu(self, *Locks::runtime_shutdown_lock_);
runtime->EndThreadBirth();
}
// Manually delete the global reference since Thread::Init will not have been run.
env->DeleteGlobalRef(child_thread->tlsPtr_.jpeer);
child_thread->tlsPtr_.jpeer = nullptr;
delete child_thread;
child_thread = nullptr;
// TODO: remove from thread group?
env->SetLongField(java_peer, WellKnownClasses::java_lang_Thread_nativePeer, 0);
{
std::string msg(child_jni_env_ext.get() == nullptr ?
"Could not allocate JNI Env" :
StringPrintf("pthread_create (%s stack) failed: %s",
PrettySize(stack_size).c_str(), strerror(pthread_create_result)));
ScopedObjectAccess soa(env);
soa.Self()->ThrowOutOfMemoryError(msg.c_str());
}
}
这里面重点是pthread_create()函数,pthread_create是pthread库中的函数,通过syscall再调用到clone来创建线程。
再往下就到内核层了,由于篇幅限制,就先不深入,有兴趣的同学可以自行研究
线程阻塞指的是暂停一个线程的执行以等待某个条件发生(如某资源就绪)。Java提供了大量的方法来支持阻塞,下面让我们逐一分析。
sleep()允许指定以毫米为单位的一段时间作为参数,它使得线程在指定的时间内进入阻塞状态,不能得到CPU时间,指定的时间已过,线程重新进入可执行状态。典型地,sleep()被用在等待某个资源就绪的情形:测试发现条件不满足后,让线程阻塞一段后重新测试,直到条件满足为止。
两个方法配套使用,suspend()使得线程进入阻塞状态,并且不会自动恢复,必须其对应的resume()被调用,才能使得线程重新进入可执行状态。典型地,suspend()和resume()被用在等待另一个线程产生的结果的情形:测试发现结果还没有产生后,让线程阻塞,另一个线程产生了结果后,调用resume()使其恢复。
yeield()使得线程放弃当前分得的CPU时间,但是不使线程阻塞,即线程仍处于可执行状态,随时可能再次分的CPU时间。调用yield()效果等价于调度程度认为该线程已执行了足够的时间从而转到另一个线程。
两个方法配套使用,wait()使得线程进入阻塞状态,它有两种形式,一种允许指定以毫秒为单位的一段时间作为参数,另一种没有惨呼是,当前对应的notify()被调用或者超出指定时间线程重新进入可执行状态,后者则必须对应的notify()被调用。初看起来它们与suspend()和resume()方法对没有什么分别,但是事实上它们是截然不同的。区别的核心在于,前面叙述的所有方法,阻塞时都不会释放占用的锁(如果占用的话),而这一对方法则相反。
这里需要重点介绍下wait()和notify()
在多线程编程中,多个线程公用资源,计算机会多各个线程进行调度。因此各个线程会经历一系列不同的状态,以及在不同的线程间进行切换。 既然线程需要被切换,在生命周期中处于各种状态,如等待、阻塞、运行。吧线程就需要能够保存线程,在线程被切换后/回复后需要继续在上一个状态运行。这就是所谓的上下文切换。为了实现上下文切换,势必会消耗资源,造成性能损失。因为我们在进行多线程编程过程中需要减少上下文切换,提高程序运行性能。
一些常用的方法:
线程安全无非是要控制多个线程对某个资源的有序访问或修改。即多个线程,一个临界区,通过通知这些线程对临界区的访问,使得每个线程的每次执行结果都相同(搞清楚这个问题,可以避免多线程编程的狠多错误)
守护线程我觉得还是很有用的。首先看看守护进程是什么?守护线程就是后台运行的线程。普通线程结束后,守护线程自动结束。一般main线程视为守护线程,以及GC、数据库连接池等,都做成守护进程。
守护线程就像备胎一样,JRE(女神)根本不会管守护进行有没有,在不在,只要前台线程结束,就算执行完毕了。
直接调用setDeamon() 即可。
setDaemon(true) 必须在start()方法之前调用;在守护线程中开启的线程也是守护线程;守护线程中不能进行I/O操作。
Java内存模型规范了Java虚拟机与计算机内存是符合协同工作的。Java虚拟机是一个完整的计算机的一个模型,因此这个模型自然也包含一个内存模型——又称为Java内存模型。
如果你想设计表现良好的并发程序,理解Java内存模型是非常重要的。Java内存模型规定了如何和何时可以看到由其他线程修改过后的共享变量的值,以及在必须时如何同步的访问共享变量。
原始的Java内存模型存在一些不足,因此Java内存模型在Java 1.5时被重新修订。这个版本的Java内存模型在Java8中仍在使用。
Java内存模型把Java虚拟机内部划分为线程栈和堆。下面这张图演示了Java内存模型的逻辑视图。
Java内存模型原理.png
下面这张图演示了调用栈和本地变量存放在线程栈上,对象存放在堆上。
堆与栈.png
所以大体可以分为以下几种情况:
下图演示了上面提到的点:
情况.png
PS:
上面这张图也展示了指向堆上两个不同对象的一个本地变量。在这种情况下,指向两个不同对象的引用不是同一个对象。理论上,两个线程都可以访问Object 1 和Object 5,如果两个线程都拥有两个对象的引用。但是在上图中,每个线程仅有一个引用指向两个对象其中之一。
现代硬件内存模型与Java模型有一些不同。理解内存模型结构以及Java内存模型如何与它协同工作也是非常重要的。这部分描述了通用的硬件内存架构,下面的部分将会描述内存是如何与它"联合"工作的。
现代计算机硬件架构的简单图示:
现代计算机硬件架构.png
上面已经提到,Java内存模型与硬件内存架构之间存在差异。硬件内存架构没有区分线程栈和堆。对于硬件,所有的线程栈和堆都分布在主内中。部分线程栈和堆可能有时候会出现在CPU缓存中和CPU内部的寄存器中。
如下图所示:
桥接.png
当对象和变量被存放在计算机中各个不同的内存区域中时,就可能会出现一些具体的问题。主要包含两个方面:
下面我们专门来解释一下上面的两个问题
如果两个或者更多的线程在没有正确使用volatile声明或者同步的情况下共享一个对象,一个线程更新这个共享对象可能对其他线程来说是不可见的。
想象一下,共享对象那个被初始化在主存中。跑在CPU上的一个线程将这个共享对象读到CPU缓存中。然后修改了这个对象。要CPU缓存没有被刷新到驻村,对象修改后的版本对跑在其他CPU上的线程都是不可见的。这种方式可能导致每个线程拥有这个共享对象的私有拷贝,每个拷贝停留在不同的CPU缓存中。
下面示意了这种情形。
对象的可见性.png
跑在左边的CPU的线程拷贝这个共享对象到它的CPU缓存中,然后将count变量的值修改为2,这个修改对跑在右边的CPU上的其他线程是不可见的,因为修改后count的值还没有被刷新回主存中去。
解决这个问题你可以使用volatile关键字。volatile关键字可以保证直接从主存中读取一个变量,如果这个变量被修改后,总是会写回到主存中去。
如果两个或者更多的线程共享一个对象,多个线程在这个共享对象上更新变量,就可能放生Race Conditions(竞争条件)。想象一下,如果线程A读取一个共享对象的变量count到它的CPU缓存中。再想象一下,线程B也做了同样的事情,但是往一个不同的CPU缓存个中。现在线程A将count加1,线程B也做了同样的事情,现在count已经被增加了两个,每个CPU缓存中一次。如果这些增加操作被顺序执行,变量count应该被增加两次,然后原值+2倍写回到主存中区。然而,两次增加都是在没有适当的同步下并发执行的。无论线程A还是线程B将count修改后的版本写回到主存中去,修改后的值仅会被原值大1,尽管增加了两次。
下图演示了上面描述的情况:
Race Conditions.png
解决这个问题可以使用Java同步块。一个同步块可以保证在同一时刻仅有一个线程可以进入代码的临界区。同步块还可以保证代码块中所有被访问的变量将会从主存中读入,当线程退出同步代码块是,所有被更新的变量会被刷新回主存中区,不管这个变量是否被声明为volatile。