线程基础_马也 invo-CSDN博客

一、线程的基本概念
在操作系统中两个比较容易混淆的概念是进程（process）和线程（thread）。操作系统中的进程是资源的组织单位。进程有一个包含了程序内容和数据的地址空间，以及其它的资源，包括打开的文件、子进程和信号处理器等。不同进程的地址空间是互相隔离的。而线程表示的是程序的执行流程，是CPU调度的基本单位。线程有自己的程序计数器、寄存器、栈和帧等。引入线程的动机在于操作系统中阻塞式I/O的存在。当一个线程所执行的I/O被阻塞的时候，同一进程中的其它线程可以使用CPU来进行计算。这样的话，就提高了应用的执行效率。线程的概念在主流的操作系统和编程语言中都得到了支持。
一部分的Java程序是单线程的。程序的机器指令按照程序中给定的顺序依次执行。Java语言提供了java.lang.Thread类来为线程提供抽象。有两种方式创建一个新的线程：一种是继承java.lang.Thread类并覆写其中的run()方法，另外一种则是在创建java.lang.Thread类的对象的时候，在构造函数中提供一个实现了java.lang.Runnable接口的类的对象。在得到了java.lang.Thread类的对象之后，通过调用其start()方法就可以启动这个线程的执行。
一个线程被创建成功并启动之后，可以处在不同的状态中。这个线程可能正在占用CPU时间运行；也可能处在就绪状态，等待被调度执行；还可能阻塞在某个资源或是事件上。多个就绪状态的线程会竞争CPU时间以获得被执行的机会，而CPU则采用某种算法来调度线程的执行。不同线程的运行顺序是不确定的，多线程程序中的逻辑不能依赖于CPU的调度算法。
　　Windows操作系统是支持多线程的，它可以同时执行很多个线程，也支持多进程，因此Windows操作系统是支持多线程多进程的操作系统。Linux和Uinux也是支持多线程和多进程的操作系统。DOS就不是支持多线程和多进程了，它只支持单进程，在同一个时间点只能有一个进程在执行，这就叫单线程。
　　CPU难道真的很神通广大，能够同时执行那么多程序吗？不是的，CPU的执行是这样的：CPU的速度很快，一秒钟可以算好几亿次，因此CPU把自己的时间分成一个个小时间片，我这个时间片执行你一会，下一个时间片执行他一会，再下一个时间片又执行其他人一会，虽然有几十个线程，但一样可以在很短的时间内把他们通通都执行一遍，但对我们人来说，CPU的执行速度太快了，因此看起来就像是在同时执行一样，但实际上在一个时间点上。
　　那什么才是真正的多线程？如果你的机器是双CPU，或者是双核，这确确实实是多线程。

二、线程的创建和启动

　　在JAVA里面，JAVA的线程是通过java.lang.Thread类来实现的，每一个Thread对象代表一个新的线程。创建一个新线程出来有两种方法：第一个是从Thread类继承，另一个是实现接口runnable。VM启动时会有一个由主方法(public static void main())所定义的线程，这个线程叫主线程。可以通过创建Thread的实例来创建新的线程。你只要new一个Thread对象，一个新的线程也就出现了。每个线程都是通过某个特定的Thread对象所对应的方法run()来完成其操作的，方法run()称为线程体。

Demo1：实现Runnable接口创建和启动新线程

 
  package com.liangdianshui;  
  
public class ThreadRunable {  
    public static void main(String args[]) {  
        MyRunable mRunable = new MyRunable();  
        // r1.run();//这个称为方法调用，方法调用的执行是等run()方法执行完之后才会继续执行main()方法  
        new Thread(mRunable).start();  //启动一个线程  
        for (int i = 0; i < 10; i++) {  
            System.out.println("main：" + i);  
        }  
    }  
}  
  
/** 
 * 自定义一个类，实现Runable接口 打印1-10 
 * 
 */  
class MyRunable implements Runnable {  
    public void run() {  
        for (int i = 0; i < 10; i++) {  
            System.out.println("MyRunable：" + i);  
        }  
    }  
}  
 
 

运行结果：

在我的机子上运行的结果是这样，在你们的机子上运行的结果也可能不一样的！他的运行原理是这样的：

Demo2：继承Thread类,重run()方法创建和启动新的线程

 
   [java]  
   view plain 
    copy 
     
    
    
  
package com.liangdianshui;  
  
public class ThreadExtendThread {  
    public static void main(String[] args) {  
        MyThread mThread = new MyThread();  
        mThread.start(); // 开启一个新的线程  
        for (int i = 0; i < 10; i++) {  
            System.out.println("main:" + i);  
        }  
    }  
}  
  
/** 
 * 继承Thread 
 * 
 */  
class MyThread extends Thread {  
    @Override  
    public void run() {  
        super.run();  
        for (int i = 0; i < 10; i++) {  
            System.out.println("MyThread: " + i);  
        }  
    }  
}  
 使用实现Runnable接口和继承Thread类这两种开辟新线程的方法,在选择上：应该优先选择实现Runnable接口这种方式去开辟一个新的线程。因为接口的实现可以实现多个，而类的继承只能是单继承。因此在开辟新线程时能够使用Runnable接口就尽量不要使用从Thread类继承的方式来开辟新的线程。
        通过上面的例子，我们可以这样理解线程，主线程就是一个部门的主管，当遇到比较耗时的工作的时候，他可以安排部门的其他员工帮忙做，然后他自己继续做下面的事情，最后只要知道员工完成的结果就行了~！
三、线程状态转换
  
      
    
3.1.线程控制的基本方法
 
      
    
3.2. sleep/join/yield方法介绍
 
      
    
 Demo：
 
      [java]  
      view plain 
       copy 
        
       
       
     
package com.liangdianshui;  
  
import java.util.Date;  
  
public class ThreadRunable {  
    public static void main(String args[]) {  
        MyRunable mRunable = new MyRunable();  
        // r1.run();//这个称为方法调用，方法调用的执行是等run()方法执行完之后才会继续执行main()方法  
        new Thread(mRunable).start(); // 启动一个线程  
        for (int i = 0; i < 10; i++) {  
            System.out.println("main：" + i);  
            if (i == 5) {  
                try {  
                    System.out.println(new Date().toLocaleString());  //打印当前时间  
                    Thread.sleep(5000); // 让主线程休眠5秒  
                    System.out.println(new Date().toLocaleString());  //打印当前时间  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
    }  
}  
  
/** 
 * 自定义一个类，实现Runable接口 打印1-10 
 * 
 */  
class MyRunable implements Runnable {  
    public void run() {  
        for (int i = 0; i < 10; i++) {  
            System.out.println("MyRunable：" + i);  
        }  
    }  
}  
 运行结果：
 
 Demo:
 
      [java]  
      view plain 
       copy 
        
       
       
     
package com.liangdianshui;  
  
import java.util.Date;  
  
public class ThreadRunable {  
    public static void main(String args[]) {  
        MyRunable mRunable = new MyRunable();  
        // r1.run();//这个称为方法调用，方法调用的执行是等run()方法执行完之后才会继续执行main()方法  
        Thread mThread = new Thread(mRunable);  
        mThread.start(); // 启动一个线程  
        for (int i = 0; i < 10; i++) {  
            System.out.println("main：" + i);  
        }  
        try {  
            mThread.join();  //把子线程合并到主线程，等于是调用子线程的方法  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
    }  
}  
  
/** 
 * 自定义一个类，实现Runable接口 打印1-10 
 * 
 */  
class MyRunable implements Runnable {  
    public void run() {  
        for (int i = 0; i < 10; i++) {  
            System.out.println("MyRunable：" + i);  
            if (i == 2) {  
                try {  
                    Thread.sleep(2000);  
                } catch (InterruptedException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
            }  
        }  
    }  
}  
 运行结果：
 
      
    
 
      join方法你可以理解为是直接停止了那个子线程，然后在主线程中继续运行！ 
    

 Demo：
  
       [java]  
       view plain 
        copy 
         
        
        
      
package com.liangdianshui;  
  
import java.util.Date;  
  
public class ThreadRunable {  
    public static void main(String args[]) {  
        MyThread1 t1 = new MyThread1("t1");  
        MyThread1 t2 = new MyThread1("t2");  
        t1.start();  
        t2.start();  
    }  
}  
  
class MyThread1 extends Thread {  
  
    private String strName;  
  
    public MyThread1(String str) {  
        strName = str;  
    }  
  
    public void run() {  
        for (int i = 0; i < 10; i++) {  
            System.out.println(strName + "：" + i);  
            try {  
                Thread.sleep(1000); //为了更好的显示效果，增加延迟  
            } catch (InterruptedException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
            if (i % 2 == 0) {  
                yield();  
            }  
        }  
    }  
  
}  
 
       
     
 
       四、线程的优先级别 
       
 
      
 
       
  
      
 
       五、线程同步
  
      
 
       
  
      
 
       
  
      
六、总结
         这篇博文首先简单的介绍了什么是进程和线程，知道单个CPU不是真正意义上的多进程，CPU把自己的时间分成一个个小时间片，我这个时间片执行你一会，下一个时间片执行他一会，加上CPU的运行速度很快，因此像同时运行多个程序一样，然后了解实现Thread的两种方法，一种是实现Runable接口，一种是继承Thread类，最后讲了线程的一些方法！