不知道从什么时候开始,学习知识变成了一个短期记忆的过程,总是容易忘记自己当初学懂的知识(fuck!),不知道是自己没有经常使用还是当初理解的不够深入.今天准备再对java的线程进行一下系统的学习,希望能够更好的理解使用java线程.

  1. 什么是线程,线程与进程的差别?(这一块内容我想我已经有了一个理解,这里就不再做记录了)

  2.java线程的状态:

从百度上随便找了一张图,图中已经很清楚的标注了thread的各个状态以及状态的变化的场景.我们会在接下来的章节中进行相关讲解.

  3.java实现多线程的方式:

A: 继承Thread类:(在下面的章节进行源码分析)

      

  1. public class ThreadTest {
  2. public static void main(String[] args) {
  3. Thread1 thread1 = new Thread1();
  4. thread1.start();
  5. }
  6. }
  7. class Thread1 extends Thread{
  8. public void run () {
  9. try {
  10. Thread.sleep(100L);
  11. } catch (InterruptedException e) {
  12. // TODO Auto-generated catch block
  13. e.printStackTrace();
  14. }
  15. }
  16. }

    B: 实现Runnable接口.

  1. public class ThreadTest {
  2. public static void main(String[] args) {
  3. Thread thread2 = new Thread(new Thread2());
  4. thread2.start();
  5. }
  6. }
  7. class Thread2 implements Runnable{
  8. @Override
  9. public void run() {
  10. try {
  11. Thread.sleep(100L);
  12. } catch (InterruptedException e) {
  13. // TODO Auto-generated catch block
  14. e.printStackTrace();
  15. }
  16. }
  17. }

  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()方法来检查当前线程是否有权限操作此线程.

  1. java源码:
  2. Thread parent = currentThread();
  3. SecurityManager security = System.getSecurityManager();
  4. if (g == null) {
  5. /* Determine if it's an applet or not */
  6.  
  7. /* If there is a security manager, ask the security manager
  8. what to do. */
  9. if (security != null) {
  10. g = security.getThreadGroup();
  11. }
  12.  
  13. /* If the security doesn't have a strong opinion of the matter
  14. use the parent thread group. */
  15. if (g == null) {
  16. g = parent.getThreadGroup();
  17. }
  18. }
  19.  
  20. /* checkAccess regardless of whether or not threadgroup is
  21. explicitly passed in. */
  22. g.checkAccess();

  其中Thread类的daemon,priority属性会由父类继承.

  6.Thread类中的方法:

    Thread.sleep(): 此方法调用的是native的方法,本人不才,记得当初看过jdk源码,但是并没看懂底层实现。sleep方法是使当前线程休眠,讲cpu占用权交给其他任意优先级的线程。但是我们应该注意:sleep方法并不会释放对象锁。

    Thread.join():  记得当初查看api的时候觉得api对join方法的解释非常模糊。到底是谁等待谁结束,这有歧义。其实是这样的,在java7 api中介绍的很清楚,是调用join的线程等待被调用线程执行结束之后再开始执行。这里有一个很值得注意的问题,join的底层调用的是wait方法,而且是循环调用,源码如下:

  1. long base = System.currentTimeMillis();
  2. long now = 0;
  3.  
  4. if (millis < 0) {
  5. throw new IllegalArgumentException("timeout value is negative");
  6. }
  7.  
  8. if (millis == 0) {
  9. while (isAlive()) {
  10. wait(0);
  11. }
  12. } else {
  13. while (isAlive()) {
  14. long delay = millis - now;
  15. if (delay <= 0) {
  16. break;
  17. }
  18. wait(delay);
  19. now = System.currentTimeMillis() - base;
  20. }
  21. }

  我们可以看到源码中join方法会在while循环中一直调用wait方法,这是因为如果wait的时间是1000ms,如果在100ms的时候另外一个线程调用了notifyAll方法,那么线程就会苏醒。还要注意第二个问题,就是join调用wait方法,那么我们知道当main线程调用ThreadA.join的时候,main函数会获取ThreadA对象的锁。当ThreadA线程执行完成之后释放该对象锁。下面我们通过一个例子来验证一下上面的论述:我们新建三个线程,B,C,D,然后在B-C-D中进行循环调用。

  1. public class ThreadTest {
  2. public static ThreadB threadB = new ThreadB();
  3. public static void main(String[] args) throws InterruptedException{
  4. System.out.println("main线程开始调用B.join");
  5. threadB.start();
  6. threadB.join();
  7. }
  8. }
  9. class ThreadB extends Thread{
  10. public void run(){
  11. try {
  12. System.out.println("ThreadB执行ThreadC.join");
  13. ThreadC threadC = new ThreadC();
  14. threadC.start();
  15. threadC.join();
  16. } catch (InterruptedException e) {
  17. // TODO Auto-generated catch block
  18. e.printStackTrace();
  19. }
  20. }
  21. }
  22. class ThreadC extends Thread{
  23. public void run(){
  24. try {
  25. System.out.println("ThreadC执行ThreadD.join");
  26. ThreadD threadD = new ThreadD();
  27. threadD.start();
  28. threadD.join();
  29. } catch (InterruptedException e) {
  30. // TODO Auto-generated catch block
  31. e.printStackTrace();
  32. }
  33. }
  34. }
  35. class ThreadD extends Thread{
  36. public void run(){
  37. try {
  38. System.out.println("ThreadD执行ThreadB.join");
  39. ThreadTest.threadB.join();
  40. } catch (InterruptedException e) {
  41. // TODO Auto-generated catch block
  42. e.printStackTrace();
  43. }
  44. }
  45. }
  46.  
  47. 结果:
  48. main线程开始调用B.join
  49. ThreadB执行ThreadC.join
  50. ThreadC执行ThreadD.join
  51. 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方法来新建一个线程。

  至此: 线程的基础知识就结束了,下一章我们会学习关于线程锁的相关知识。

 

    

java线程基础知识----线程基础知识的更多相关文章

  1. Java并发之线程管理(线程基础知识)

    因为书中涵盖的知识点比较全,所以就以书中的目录来学习和记录.当然,学习书中知识的时候自己的思考和实践是最重要的.说到线程,脑子里大概知道是个什么东西,但很多东西都还是懵懵懂懂,这是最可怕的.所以想着细 ...

  2. java核心-多线程(4)-线程类基础知识

    1.并发 <1>使用并发的一个重要原因是提高执行效率.由于I/O等情况阻塞,单个任务并不能充分利用CPU时间.所以在单处理器的机器上也应该使用并发. <2>为了实现并发,操作系 ...

  3. [C#.NET 拾遗补漏]11:最基础的线程知识

    线程的知识太多,知识点有深有浅,往深的研究会涉及操作系统.CUP.内存,往浅了说就是一些语法.没有一定的知识积累,很难把线程的知识写得全面,当然我也没有这个能力.所以想到一个点写一个点,尽量总结一些有 ...

  4. JAVA面试题集之基础知识

                           JAVA面试题集之基础知识 基础知识:  1.C 或Java中的异常处理机制的简单原理和应用. 当JAVA程序违反了JAVA的语义规则时,JAVA虚拟机就 ...

  5. Java 面试知识点解析(一)——基础知识篇

    前言: 在遨游了一番 Java Web 的世界之后,发现了自己的一些缺失,所以就着一篇深度好文:知名互联网公司校招 Java 开发岗面试知识点解析 ,来好好的对 Java 知识点进行复习和学习一番,大 ...

  6. Java基础篇——线程、并发编程知识点全面介绍(面试、学习的必备索引)

    原创不易,如需转载,请注明出处https://www.cnblogs.com/baixianlong/p/10739579.html,希望大家多多支持!!! 一.线程基础 1.线程与进程 线程是指进程 ...

  7. java多线程系类:基础篇:09之interrupt()和线程终止方式

    概要 本章,会对线程的interrupt()中断和终止方式进行介绍.涉及到的内容包括:1. interrupt()说明2. 终止线程的方式2.1 终止处于"阻塞状态"的线程2.2 ...

  8. JAVA基础拾遗-论线程池的线程粒度划分与深浅放置

    摘要:多线程任务处理对提高性能很有帮助,在Java中提供的线程池也方便了对多线程任务的实现.使用它很简单,而如果进行了不正确的使用,那么代码将陷入一团乱麻.因此如何正确地使用它,如以下分享,这个技能你 ...

  9. Java中实现异常处理的基础知识

    Java中实现异常处理的基础知识 异常 (Exception):发生于程序执行期间,表明出现了一个非法的运行状况.许多JDK中的方法在检测到非法情况时,都会抛出一个异常对象. 例如:数组越界和被0除. ...

  10. Java视频扩展知识 线程池的了解

     Java视频扩展知识   线程池的了解 1.简单介绍: Jdk1.5之后加入了java.util.concurrent包,这个包中主要介绍java中线程以及线程池的使用.为我们在开发中处理线程的 ...

随机推荐

  1. Network IP Availability Extension

    可以查询网络的IP使用情况 neutron net-ip-availability-list neutron net-ip-availability-show GET /v2.0/network-ip ...

  2. MATLAB卷积运算(conv、conv2)解释

    来源:https://www.cnblogs.com/hyb221512/p/9276621.html 1.conv(向量卷积运算) 所谓两个向量卷积,说白了就是多项式乘法.比如:p=[1 2 3], ...

  3. unit Base64Unit;

    unit Base64Unit; unit Base64Unit; //Download by http://www.codefans.net interface uses Classes, SysU ...

  4. Python编程-一个小爬虫工具的实现过程

    需求描述: 1,打开网站: 2,获取网站的文件内容: 3,返回保存到文件中: 这里的就用到了多线程的方法 import requests,threading,time def write_html(u ...

  5. C++ 播放音频流(PCM裸流)

    直接上代码,如果有需要可以直接建一个win32控制台程序然后将代码拷过去改个文件名就可以用了(注意将声道和频率与你自己的文件对应哦).当然我自己也用VS2008(VS2013好用太多,强烈推荐还是用V ...

  6. luogu1801 黑匣子

    惊了呀 Splay Treap 这都什么玩意 两个优先队列搞定 #include <bits/stdc++.h> using namespace std; #define LL long ...

  7. uva1160 易爆物

    #include<iostream>#include<cstdio>#include<algorithm>#include<cstdlib>using ...

  8. 系列文章--打造自己的MVC框架

    MVC源码学习系列文章目录: MVC系列——MVC源码学习:打造自己的MVC框架(一:核心原理) MVC系列——MVC源码学习:打造自己的MVC框架(二:附源码) MVC系列——MVC源码学习:打造自 ...

  9. node好用的东东

    supervisor 可参考: http://www.cnblogs.com/pigtail/archive/2013/01/08/2851056.html http://www.cnblogs.co ...

  10. 安装phpredis

    1.下载安装包 https://github.com/nicolasff/phpredis/archive/2.2.5.tar.gz 2.解压到~目录 tar -xvf phpredis-2.2.5. ...