黑马程序员—多线程（上）-线程及其创建方法

---------------------- android培训、java培训、期待与您交流！ ----------------------

1.进程与线程

进程：

是一个正在执行中的程序。
每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。

线程：
就是进程中的一个独立的控制单元。
线程在控制着进程的执行。一个进程中至少有一个线程。

2.线程运行状态与常用方法

2.1线程运行状态

2.2常用方法

setPriority(int newPriority)更改线程的优先级。

start() 使该线程开始执行；Java虚拟机调用该线程的 run方法。
sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）

yield() 暂停当前正在执行的线程对象，并执行其他线程。

currentThread()返回对当前正在执行的线程对象的引用。
getName():获取线程名称。
System.currentTimeMillis(); 获取当前毫秒数。
setName() 设置线程的名称或者构造函数。

3.线程的创建方式

3.1创建方式一：

3.1.1步骤：

1.定义一个类并继承Thread类。
2.复写Thread类中的run方法。目的就是将自定义代码存储在run方法，让线程运行。
3.调用线程的start()启动线程。start()自动调用run方法

class Demo extends Thread {             //Demo类继承Thread类  
 	    public void run(){                  //复写run方法  
 	        for (int x=0;x<=50 ;x++ )       //该线程执行的任务  
 	            System.out.println("demo run---"+x);  
 	    }  
 	}  
 	  
 	class ThreadDemo{  
 	    public static void main(String[] args) {  
 	        Demo d = new Demo();            //创建线程  
 	        d.start();                      //开始执行线程  
 	        for (int x=0;x<=50 ;x++ )       //主线程执行的任务  
 	            System.out.println("---main run---"+x);  
 	    }  
 	}  

3.1.2run()和start()方法

为什么覆盖run方法？
Thread类用于描述线程，该类定义了一个功能，用于存储线程要运行的代码，
该存储功能就是run方法。也就是说Thread类中的run方法用于存储线程要运行的代码。

线程都有自己默认的名称：Thread-编号。该编号从0开始。

通过下面实例总结：
run() 和 start() 的区别： start 可以实现多线程， run 就不能
run() ：只是 Thread 类的一个普通方法，可以启动一个线程，但只当这个线程的 run 执行完后，才执行后面的线程。
start() ：开启线程并使线程处于一种就绪状态，等待 CPU 的运行权限，获得后调用 run 方法

class Thread1 extends Thread {  
 	    private String a=this.getName();//获取线程名称  
 	    public void run() {  
 	        for (int x=0;x<10 ;x++ )  
 	            System.out.println(a+" 1111-"+x);  
 	    }  
 	}  
 	class Thread2 extends Thread {  
 	    private String a=this.getName();//获取线程名称  
 	    public void run() {  
 	        for (int x=0;x<10 ;x++ )  
 	            System.out.println(a+" 2222-"+x);  
 	    }  
 	}  
 	class  ThreadDemo1103 {  
 	    public static void main(String[] args) {  
 	        Thread1 t1 = new Thread1();  
 	        Thread2 t2 = new Thread2();  
 	        t1.start();  
 	        t2.start();  
 	        //t1.run();  
 	        //t2.run();  
 	        for (int x=0;x<10 ;x++ )  
 	            System.out.println("Hello world----"+x);  
 	    }  
 	}

通过以上事例可以看出：

每次运行结果都不同，是因为多个线程同时获取CPU执行权，CPU执行到谁，谁就运行。
可以形象的把多线程的运行行为看成是在互相争抢CPU的执行权。
在某一时刻，只能有一个程序在运行（多核CPU除外）。

因为 CPU 在各个线程中快速切换执行，所以看上去像是同时运行一样。
这就是多线程的一个特性：随机性。谁抢到谁执行，执行多长时间， CPU 说的算。

3.2创建方式二：

3.2.1步骤

1.定义类实现Runnable接口
2.复写Runnable接口中的run方法。将线程和车票的代码放在run方法中。
3.通过Thread类建立线程对象。
4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。

//实现Runnable接口  
 	class Ticket implements Runnable {  
 	    //初始化票数。  
 	    private static int tick = 100;   
 	    //复写Runnable接口的run方法  
 	    public void run(){  
 	        while(tick>0){  
 	            if(tick>0){  
 	                String WinName = Thread.currentThread().getName();  
 	                System.out.println(WinName+"："+tick--);  
 	            }  
 	        }  
 	    }  
 	}  
 	class TicketDemo{  
 	    public static void main(String[] args){  
 	        Ticket t = new Ticket();  
 	        //在创建线程对象的同时，就指定run方法所属对象。  
 	        //通过Thread类创建4个线程对象。表示四个售票窗口。  
 	        //将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。  
 	        Thread t1 = new Thread(t);  
 	        Thread t2 = new Thread(t);  
 	        Thread t3 = new Thread(t);  
 	        Thread t4 = new Thread(t);  
 	          
 	        //调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。  
 	        t1.start();  
 	        t2.start();  
 	        t3.start();  
 	        t4.start();  
 	    }  
 	}

3.2.2继承和实现的区别：

继承Thread，线程代码存放在Thread子类run方法中。

实现Runnable，线程代码存放在接口的子类的run方法中。

Runnable，避免了单继承的局限性，在定义线程时，建议使用实现方式。

3.3创建方式三：JDK.1.5创建线程池的方式创建线程

1.调用 Executors类中的静态方法创造线程池 （ ExecutorService）或者可安排在给定延迟后运行命令或者定期地执行的线程池（ScheduledExecutorService）

2.调用线程池的方法execute(Runnable command) 、在未来某个时间执行给定的命令。scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) ，将要执行的任务覆盖在command中的run方法中

import static java.util.concurrent.TimeUnit.*;
 class BeeperControl {
    private final ScheduledExecutorService scheduler = 
       Executors.newScheduledThreadPool(1);

    public void beepForAnHour() {
        final Runnable beeper = new Runnable() {
                public void run() { System.out.println("beep"); }
            };
        final ScheduledFuture<?> beeperHandle = 
            scheduler.scheduleAtFixedRate(beeper, 10, 10, SECONDS);
        scheduler.schedule(new Runnable() {
                public void run() { beeperHandle.cancel(true); }
            }, 60 * 60, SECONDS);
    }
 }