不知道从什么时候开始,学习知识变成了一个短期记忆的过程,总是容易忘记自己当初学懂的知识(fuck!),不知道是自己没有经常使用还是当初理解的不够深入.今天准备再对java的线程进行一下系统的学习,希望能够更好的理解使用java线程.
1. 什么是线程,线程与进程的差别?(这一块内容我想我已经有了一个理解,这里就不再做记录了)
2.java线程的状态:
从百度上随便找了一张图,图中已经很清楚的标注了thread的各个状态以及状态的变化的场景.我们会在接下来的章节中进行相关讲解.
3.java实现多线程的方式:
A: 继承Thread类:(在下面的章节进行源码分析)
public class ThreadTest {
public static void main(String[] args) {
Thread1 thread1 = new Thread1();
thread1.start();
}
}
class Thread1 extends Thread{
public void run () {
try {
Thread.sleep(100L);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
B: 实现Runnable接口.
public class ThreadTest {
public static void main(String[] args) {
Thread thread2 = new Thread(new Thread2());
thread2.start();
}
}
class Thread2 implements Runnable{
@Override
public void run() {
try {
Thread.sleep(100L);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
4. 实现多线程的两种方法的差别:
A. 众所周知java不允许多继承,那么我们集成Runnable接口实现多集成就能够很好的避免这个限制.
B.集成Runnable接口实现多线程有利于程序操作共享资源(后面会提到)
这个理解起来很简单: 我们继承了Thread类实现run方法之后我们可以发现这样一个问题,我们再进行线程实例化之后我们必须分别启动线程任务.
而我们实现Runnable接口的话,我们可以实例化多个Thread类来运行这个任务.
当然集成Thread类也并不是不能完成共享资源的分发,而是比较费劲.
5. 实例化:我们在初始化Thread类的时候会调用Thread内部的init方法,即便是我们不提供任何参数.init函数的结构: private void init(ThreadGroup g, Runnable target, String name,long stackSize)
参数有:ThreadGroup,Target,name.stackSize,其中ThreadGroup会递归去调用父类的getThreadGroup来进行初始化,等待初始化完成之后我们会通过ThreadGroup调用checkAccess()方法来检查当前线程是否有权限操作此线程.
java源码:
Thread parent = currentThread();
SecurityManager security = System.getSecurityManager();
if (g == null) {
/* Determine if it's an applet or not */ /* If there is a security manager, ask the security manager
what to do. */
if (security != null) {
g = security.getThreadGroup();
} /* If the security doesn't have a strong opinion of the matter
use the parent thread group. */
if (g == null) {
g = parent.getThreadGroup();
}
} /* checkAccess regardless of whether or not threadgroup is
explicitly passed in. */
g.checkAccess();
其中Thread类的daemon,priority属性会由父类继承.
6.Thread类中的方法：
Thread.sleep(): 此方法调用的是native的方法，本人不才，记得当初看过jdk源码，但是并没看懂底层实现。sleep方法是使当前线程休眠，讲cpu占用权交给其他任意优先级的线程。但是我们应该注意：sleep方法并不会释放对象锁。
Thread.join(): 记得当初查看api的时候觉得api对join方法的解释非常模糊。到底是谁等待谁结束，这有歧义。其实是这样的，在java7 api中介绍的很清楚，是调用join的线程等待被调用线程执行结束之后再开始执行。这里有一个很值得注意的问题，join的底层调用的是wait方法，而且是循环调用，源码如下：
long base = System.currentTimeMillis();
long now = 0; if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
} if (millis == 0) {
while (isAlive()) {
wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
我们可以看到源码中join方法会在while循环中一直调用wait方法，这是因为如果wait的时间是1000ms，如果在100ms的时候另外一个线程调用了notifyAll方法，那么线程就会苏醒。还要注意第二个问题，就是join调用wait方法，那么我们知道当main线程调用ThreadA.join的时候，main函数会获取ThreadA对象的锁。当ThreadA线程执行完成之后释放该对象锁。下面我们通过一个例子来验证一下上面的论述：我们新建三个线程，B，C，D，然后在B-C-D中进行循环调用。
public class ThreadTest {
public static ThreadB threadB = new ThreadB();
public static void main(String[] args) throws InterruptedException{
System.out.println("main线程开始调用B.join");
threadB.start();
threadB.join();
}
}
class ThreadB extends Thread{
public void run(){
try {
System.out.println("ThreadB执行ThreadC.join");
ThreadC threadC = new ThreadC();
threadC.start();
threadC.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
class ThreadC extends Thread{
public void run(){
try {
System.out.println("ThreadC执行ThreadD.join");
ThreadD threadD = new ThreadD();
threadD.start();
threadD.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
class ThreadD extends Thread{
public void run(){
try {
System.out.println("ThreadD执行ThreadB.join");
ThreadTest.threadB.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
结果：
main线程开始调用B.join
ThreadB执行ThreadC.join
ThreadC执行ThreadD.join
ThreadD执行ThreadB.join
可以发现我们的程序一直停留在这个位置，这是因为三个线程满足了死锁的条件，同时也可以证明，thread.join()的调用者必定会获取被调用者的锁。
Thread.yield: 此方法与sleep方法类似，但是需要注意一个问题就是Thread.yield只能讲cpu的使用权转交给同等优先级的线程。
Thread.start: 最后我们谈一谈Thread.start方法，想必大家都知道Thread.start方法会启动线程，并且执行run方法中的内容。你是否会想我们为什么不直接调用Thread.run来执行呢？其实是这样的，如果我们调用Thread.run来执行的话，jvm并不会真正的启动一个线程，而是将其当做一个普通的方法执行。而调用start的话，在start内部会调用start0方法来新建一个线程。
至此： 线程的基础知识就结束了，下一章我们会学习关于线程锁的相关知识。