黑马程序员——java多线程

最新推荐文章于 2015-10-19 13:55:29 发布

Kevin_CLJ

最新推荐文章于 2015-10-19 13:55:29 发布

阅读量321

点赞数 1

分类专栏： java编程

本文链接：https://blog.csdn.net/u014243708/article/details/44132789

版权

java编程专栏收录该内容

10 篇文章 0 订阅

订阅专栏

一、程序、进程与多任务

程序（program）是对数据描述与操作的代码的集合，是应用程序执行的脚本。

进程（process）是程序的一次执行过程，是系统运行程序的基本单位。程序是静态的，进程是动态的。系统运行一个程序即是一个进程从创建、运行到消亡的过程。

多任务（multi task）在一个系统中可以同时运行多个程序，即有多个独立运行的任务，每个任务对应一个进程。

二、线程

线程（thread）：比进程更小的运行单位，是程序中单个顺序的流控制。一个进程中可以包含多个线程。

简单来讲，线程是一个独立的执行流，是进程内部的一个独立执行单元，相当于一个子程序。

一个进程中的所有线程都在该进程的虚拟地址空间中，使用该进程的全局变量和系统资源。

操作系统给每个线程分配不同的CPU时间片，在某一时刻，CPU只执行一个时间片内的线程，多个时间片中的相应线程在CPU内轮流执行。

三、创建多线程

1.创建 java.lang.Thread 类的子类，重写该类的 run方法

2.创建 java.lang.Runnable接口的实现类，实现接口中的 run 方法

public class ThreadTest {

	public static void main(String[] args) {
		MyThread myThread = new MyThread();
		myThread.start();
		while(true){
			System.out.println("main()运行");
		}

	}
	

}

class MyThread extends Thread{
	public void run(){
		while(true){
			System.out.println("mythread运行");
		}
	}
}

public class ThreadTest2 {

	public static void main(String[] args) {
		MyThread myThread = new MyThread();
		Thread thread = new Thread(myThread);
		thread.start();
		while(true){
			System.out.println("main()运行");
		}

	}

}

class MyThread implements Runnable{
	public void run(){
		while(true){
			System.out.println("run()运行");
		}
	}
}

四、线程的生命周期

运行状态（Running）

处在“可执行状态”的线程对象一旦获得了 CPU 控制权，就会转换到“执行状态”

在“执行状态”下，线程状态占用 CPU 时间片段，执行run 方法中的代码

处在“执行状态”下的线程可以调用 yield 方法，该方法用于主动出让 CPU 控制权。线程对象出让控制权后回到“可执行状态”，重新等待调度。

public class ThreadTest3 {

	public static void main(String[] args) {
		MyThread2 myThread1 = new MyThread2("t1");
		MyThread2 myThread2 = new MyThread2("t2");
		myThread1.start();
		myThread2.start();

	}
	

}

class MyThread2 extends Thread{
	MyThread2(String s){
		super(s);
	}
	public void run(){
		for(int i = 0; i < 1000; i++){
			System.out.println(getName() + ":" + i);
			if(i % 10 == 0)
				yield();
		}
	}
	
}

阻塞状态（Blocking）

线程在“执行状态”下由于受某种条件的影响会被迫出让CPU控制权，进入“阻塞状态”。

进入阻塞状态的三种情况

调用sleep方法

调用join方法

执行I/O操作

阻塞状态（Blocking）

线程在“执行状态”下由于受某种条件的影响会被迫出让CPU控制权，进入“阻塞状态”。

进入阻塞状态的三种情况

调用sleep方法

调用join方法

执行I/O操作

sleep()方法

调用sleep方法

public void sleep(long millis)

Thread类的sleep方法用于让当前线程暂时休眠一段时间

参数 millis 的单位是毫秒

public class SleepThreadTest extends Thread{
	public void run(){
		while(true){
			System.out.println("每隔一秒钟输出一次");
			try{
				sleep(1000);
			}catch(InterruptedExcption e){
				e.printStackTrace();
			}
		}
	}
}

调用 join 方法（合并某个线程）

处在“执行状态”的线程如果调用了其他线程的 join 方法，将被挂起进入“阻塞状态”

目标线程执行完毕后才会解除阻塞，回到 “可执行状态”

执行I/O操作

线程在执行过程中如果因为访问外部资源（等待用户键盘输入、访问网络）时发生了阻塞，也会导致当前线程进入“阻塞状态”。

解除阻塞

睡眠状态超时

调用 join 后等待其他线程执行完毕

I/O 操作执行完毕

调用阻塞线程的 interrupt 方法（线程睡眠时，调用该线程的interrupt方法会抛出InterruptedException

死亡状态（Dead）：处于“执行状态”的线程一旦从run方法返回（无论是正常退出还是抛出异常），就会进入“死亡状态”。

已经“死亡”的线程不能重新运行，否则会抛出IllegalThreadStateException

可以使用 Thread 类的 isAlive方法判断线程是否活着

多线程的同步：

多线程并发访问同一个对象（临界资源），如果不对线程进行同步控制，破坏了原子操作(不可再分的操作)，则会造成临界资源(两个线程同时访问的资源)的数据不一致。

每一个对象都有一个互斥的锁标记和一个锁池。当线程拥有这个对象的锁标记时才能访问这个资源，没有锁标记便进入锁池，保证在同步代码块中只有一个线程，解决了多线程同步控制的问题。

关键字：synchronized //线程在同步代码中必须采用串行访问

synchronized修饰代码块：对括号内的对象object加锁，只有拿到对象锁标记的线程才能进入该代码块。

  publicvoid push(char c){
                                            synchronized(object){    //object只要是对象就可以，但必须保证是同一对象
                                                     ……
                                                     同步代码
                                                     ……
                                            }
                                }

synchronized修饰方法：在整个方法范围内对当前对象的加锁，只有拿到对象锁标记的线程才能执行该方法。尽可能的少用

publicsynchronized void push(char c) {
                                             ……
                                             同步代码
                                             ……  
                                    }

一个线程可以同时拥有多个对象的锁标记，锁标记如果过多，就会出现线程等待其他线程释放锁标记，而又都不释放自己的锁标记供其他线程运行的状况，造成死锁。

静态方法可以是同步方法：但是它所锁的并不是当前对象，是类对象。

抽象方法不能是synchronized同步的方法。

构造方法不能是synchronized同步的方法。

线程因为未拿到锁标记而发生阻塞进入锁池（lock pool）。每个对象都有自己的一个锁池的空间，用于放置等待运行的线程。由系统决定哪个线程拿到锁标记并运行

利用Collections类中的synchronizedXxxx(Xxxx ss)方法可以得到相应集合的线程安全的集合

注意：

在同步语句块中不能直接操作对象锁正在使用的对象。

对象与锁一一对应。

同步依赖对象锁，锁对象相同，同步语句串行，锁对象不同，同步语句并行。

顺序锁，不要回调，反向打开。

能不用同步就不用同步，有数据共享冲突时才使用同步。

等待通知机制：

线程间通信使用的空间称之为对象的等待对列（wait pool），该队列也是属于对象的空间的。

使用Object类中wait()的方法，在运行状态中，线程调用wait()，此时表示线程将释放自己所有的锁标记和CPU的占用，同时进入这个对象的等待池。等待池的状态也是阻塞状态，只不过线程释放自己的锁标记。只有在对该对象加锁的同步代码块里，才能掉用该对象的wait()，表示线程将会释放所有锁标记，进入等待队列，线程将进入等待队列状态。

一个线程进入了一个对对象加锁的同步代码块，并对该对象调用了wait()方法，释放自己拥有的所有锁标记，进入该对象等待队列，另一个线程获得了该对象的锁标记，进入代码块对该对象调用了notify()方法，就会从等待队列里释放出一线程，释放出的这个线程要继续运行就还要进入那个同步代码块，因为得不到要访问代码块对象的锁标记，而进入该对象的锁池，等待锁标记释放。

什么情况下释放锁：

同类代码执行完毕。

异常未处理，错误退出。

调用wait()。