JAVA程序设计：线程的概念

一、前言

  

二、什么是线程

    线程，一般指的是进程中执行任务的流程。

    每个进程开启后都会拥有独立的内存空间，一个进程可以执行多个线程，而多个线程共享一个进程的内存空间。

    线程只能是进程的一部分，它能够满足我们提高内存的使用效率。

三、线程的生命周期

    线程是一个动态执行的过程，它有自己的生命周期。

  

    线程的五种状态：

    新建(New)：java.lang.Thread或其子类创建一个新的线程，此时该线程处于新建状态，该线程一直在等待start()方法调用。

    就绪(Runnable)：当调用该线程对象的start()方法后，此时线程处于就绪状态，该线程并没有立即执行而是一直在等待CUP的调度。

    运行(Running)：当就绪状态的线程获取到CPU的资源后，会执行run()方法内容，此时线程处于运行状态，该线程只有处于就绪状态才能进入运行状态。

    阻塞(Blocked)：如果一个线程执行了睡眠(sleep)、等待(wait)等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：

• 等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。

• 同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。

• 其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。

    死亡(Dead)：线程执行完毕或者因异常退出，该线程结束生命周期。

    线程常用的调度方法：

• start()： 启动，开始执行该线程任务。
• run()：运行，JVM调用线程任务。
• wait()：等待，使线程进入阻塞列队。
• sleep()：休眠，使正在执行线程进入睡眠状态。
• join()：联合，把指定的线程加入到正在执行的线程，合并该线程执行任务。
• yield()：让步，暂停该线程运行，并执行其他线程。
• notify()：唤醒，使阻塞列队的线程进入就绪状态，并等待执行。
• notifyAll()：唤醒，使所有的阻塞列队的线程进入就绪状态，并等待执行。
• interrupt()：中断，让线程暂时的放弃执行任务。

四、线程的优先级

    线程的执行顺序通常与优先级相关，越高级别的优先级获得优先执行几率更大。

    线程的优先级是一个整数，其取值范围是1-10，数字越大优先级越高。

    设置线程优先级：public final int setPriority(int priority)

    线程常用的优先级：

• Thread.MIN_PRIORITY：最小优先级，数值为1
• Thread.NORM_PRIORITY：默认优先级，数值为5
• Thread.MAX_PRIORITY：最大优先级，默认为10

五、实现线程的方式

5.1 继承Thread类

public class ThreadDemo extends Thread{
	
	private String threadName;
	
	ThreadDemo(String threadName){
		this.threadName = threadName;
	}
	
	@Override
	public void run() {
		
		for (int i = 0; i < 10; i++) {
			System.out.println("Thread: " + threadName + ", " + i);
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

public static void main(String[] args) {
	ThreadDemo demo1 = new ThreadDemo("Thread-1");
	demo1.start();  // 启动线程1
		
	ThreadDemo demo2 = new ThreadDemo("Thread-2");
	demo2.start();  // 启动线程2
}

运行结果：
Thread: Thread-2, 0
Thread: Thread-1, 0
Thread: Thread-2, 1
Thread: Thread-1, 1
Thread: Thread-2, 2
Thread: Thread-1, 2
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-2, 4
Thread: Thread-1, 4
Thread: Thread-2, 5
Thread: Thread-1, 5
Thread: Thread-1, 6
Thread: Thread-2, 6
Thread: Thread-1, 7
Thread: Thread-2, 7
Thread: Thread-1, 8
Thread: Thread-2, 8
Thread: Thread-2, 9
Thread: Thread-1, 9

5.2 实现Runnable接口

public class RunnableDemo implements Runnable{
	
	private String threadName;
	
	RunnableDemo(String threadName){
		this.threadName = threadName;
	}
	
	@Override
	public void run() {
		
		for (int i = 0; i < 10; i++) {
			System.out.println("Thread: " + threadName + ", " + i);
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

public static void main(String[] args) {	
	RunnableDemo demo1 = new RunnableDemo("Thread-1");
	new Thread(demo1).start();   // 启动线程1
	
	RunnableDemo demo2 = new RunnableDemo("Thread-2");
	new Thread(demo2).start();  // 启动线程2
}

输出结果:
Thread: Thread-1, 0
Thread: Thread-2, 0
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread: Thread-2, 2
Thread: Thread-1, 2
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-2, 4
Thread: Thread-1, 4
Thread: Thread-2, 5
Thread: Thread-1, 5
Thread: Thread-1, 6
Thread: Thread-2, 6
Thread: Thread-2, 7
Thread: Thread-1, 7
Thread: Thread-1, 8
Thread: Thread-2, 8
Thread: Thread-2, 9
Thread: Thread-1, 9

5.3 实现Callable接口

public class CallableDemo implements Callable<Integer>{

	@Override
	public Integer call() throws Exception {
		
		int result = 0;
		
		for (int i = 0; i < 10; i++) {
			result = i;
			System.out.println(Thread.currentThread().getName()+" "+ i );
		}
		
		return result;
	}
}

public static void main(String[] args) {
		
	ExecutorService executor = Executors.newSingleThreadScheduledExecutor();
    CallableDemo callableDemo = new CallableDemo();
    Future<Integer> result = executor.submit(callableDemo);
    executor.shutdown();
        
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e1) {
        e1.printStackTrace();
    }
        
    try {
	    System.out.println("运行结果:"+ result.get());
	} catch (InterruptedException e) {
		e.printStackTrace();
	} catch (ExecutionException e) {
		e.printStackTrace();
	}		
}

运行结果：
pool-1-thread-1 0
pool-1-thread-1 1
pool-1-thread-1 2
pool-1-thread-1 3
pool-1-thread-1 4
pool-1-thread-1 5
pool-1-thread-1 6
pool-1-thread-1 7
pool-1-thread-1 8
pool-1-thread-1 9
运行结果:9