黑马程序员_多线程概述

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

 一、进程与线程

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

线程就是进程中的一个独立的控制单元。可以说线程在控制着进程的执行。

一个进程中至少有一个线程。

可以通过编译java代码在系统的任务管理器窗口下看到，java虚拟机启动的时候会有一个进程：java.exe。该进程中至少有一个线程负责java程序的执行，而且这个线程运行的代码存在于main方法中。该线程称之为主线程。

其实更细节说明java虚拟机，它启动的不止一个线程，还有负责垃圾回收机制的线程。

二、创建线程

创建线程的方式有两种：

第一种方式：继承Thread类

如何在自定义的代码中，创建一个线程呢？

通过对java api的查找，发现java已经提供了对线程这类事物的描述，就是Thread类。

我们可以通过如下步骤创建一个线程：

1）定义类继承Thread类。

2）复写Thread类中的run()方法。

3）调用线程的start()方法。该方法有两个作用：启动线程，调用run()方法。

注意：启动线程必须调用start()方法，如果仅仅是调用run()方法，那么就成了简单的对象调用方法，而线程创建了却没有启动。

为什么要覆盖run()方法呢？

因为Thread类用于描述线程，该类定义的run()方法，用于存储线程要运行的代码。如果子类没有重写父类的run()方法，那么实例化子类对象时会调用父类的run()方法，并不会编译报错。

例如下面的代码：我们定义了一个ThreadTest类继承Thread类，并复写了Thread类的run()方法。在ThreadDemo类的main方法中创建了两个线程对象：t1和t2，并开启了它们。这时，java虚拟机中至少有3个线程：主线程、t1线程和t2线程。

/**
创建线程演示
自定义ThreadTest类继承Thread类
*/
class ThreadTest extends Thread
{
	ThreadTest(){}

	ThreadTest(String name){
		super(name);
	}
	
	//覆盖Thread类中的run()方法
	public void run(){
		for (int i=0;i<60 ;i++ )
		{
			//打印结果
			System.out.println((Thread.currentThread()==this)+"------"+this.getName()+":+"+i+"+:run()");
		}
	}
}

class ThreadDemo 
{
	public static void main(String[] args) 
	{
		//创建线程t1
		ThreadTest t1=new ThreadTest("一");
		//创建线程t2
		ThreadTest t2=new ThreadTest("二");
		//开启线程t1
		t1.start();
		//开启线程t2
		t2.start();
		//打印主线程的运行结果
		for (int i=0;i<60 ;i++ )
		{
			System.out.println("main:+"+i+"+:Hello World!");
		}
	}
}

通过比较多次运行的结果可以发现：每次的结果都不相同。这是因为CPU的工作原理所造成的。CPU在执行任务时，它是一个线程一个线程的执行。但是我们平常使用电脑会开启很多线程，并没有这种感觉啊？这是因为CPU在做着快速的切换，以达到看上去是同时运行的效果。CPU执行到谁，谁就运行。我们可以形象的把多线程的运行看做是在互相抢夺CPU的执行权。

这就是多线程的一个特性：随机性。谁抢到CPU的执行权，那么谁就被执行。至于执行多长时间，CUP说了算。

线程的五种状态：

第二种方式：实现Runnable接口

1）定义类实现Runnable接口。

2）子类覆盖接口中的run方法。将线程要运行的代码存放在该run()方法中。

3）通过Thread类创建线程，并将实现了Runnable接口的子类对象作为参数传递给Thread类的构造函数。

为什么要将Runnable接口的子类对象传递给Thread类的构造函数呢？

因为自定义的run()方法所属的对象是Runnable接口的子类对象，所以要让线程去执行指定对象的run()方法，就必须明确该run()方法所属的对象。

4）Thread类对象调用start()方法开启线程，start()方法内部自动会调用Runnable接口子类的run()方法。

代码截图如下：该图中自定义类Ticket实现Runnable接口并复写run()方法，创建并开启了4个线程。

实现Runnable接口创建线程这种方式的好处：

避免了单继承的局限性。也就是说子类在实现Runnable接口的同时还可以继承其它父类。在定义线程时，建议使用实现方式。

实现方式和继承方式的区别：

继承Thread类，线程代码存放在Thread子类的run()方法中；实现Runnable接口，线程代码存放在接口的子类的run()方法中。 

三、多线程的同步

1、多线程的安全问题

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，CPU切换给另一个线程参与进来执行，就会导致共享数据的错误。

导致安全问题的出现的原因：

1）多个线程访问出现延迟。

2）线程的随机性 。

注：线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的。

解决办法：

对多条线程操作共享数据的语句，只能让一个线程执行完，再让其它线程继续执行。

2、同步代码块

同步代码块是java对于多线程的安全问题提供的专业的解决方式。

格式：

synchronized（对象）

{

     需要同步的代码；

}

同步可以解决安全问题的根本原因就在那个对象上。 该对象如同锁的功能。

持有锁的线程可以在同步中执行，没有持有锁的线程即使获取CPU的执行权，也进不去，因为没有获取锁。

同步的前提：

1）同步需要两个或者两个以上的线程。

2）多个线程必须使用的是同一个锁。

未满足这两个条件，不能称其为同步。也就是说必须保证同步中只能有一个线程在运行。

同步的好处：

解决了多线程的安全问题。

同步的弊端：

当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。

3、同步函数

格式：

在函数上加上synchronized修饰符即可。比如：public synchronized void add(){}

根据上面定义同步函数的格式可以看到同步函数中没有定义锁，那么同步函数使用的是哪一个锁呢？

我们知道函数需要被对象调用，那么函数都有一个所属对象引用：this，所以同步函数使用的锁是this。

如果同步函数被静态修饰后，使用的锁又是什么呢？

我们知道静态成员初始化时，内存中还没有本类对象，但是一定有本类对应的字节码文件对象，即：类名.class。该对象的类型是Class类。所以，静态的同步函数，使用的是该函数所在类的字节码文件对象。

4、线程间的通信

线程间的通信其实就是多个线程在操作同一个资源，但是操作的动作不同。

也就是说一个Student类，有name属性，一个线程可以向name属性中赋值，一个线程可以从name属性中取值。

5、等待唤醒机制

在操作同步中的线程时，必须标识所操作线程持有的锁。只有同一个锁上的被等待线程才可以被同一个锁上的notify()方法唤醒。不可以对不同锁中的线程进行唤醒。也就是说，等待和唤醒必须是同一个锁。

6、停止线程

注：java中提供的stop()停止线程的方法已经过时不再使用。

那么我们该如何停止线程呢？

1）定义循环结束标记。

因为想要让线程停止，就必须让run()方法结束。开启多线程运行，线程运行代码一般都是循环，只要控制了循环即可。

2）使用Thread类的interrupt（中断）方法。

该方法是结束线程的冻结状态，使线程回到运行状态中来。

这种方法用在特殊情况下：比如当线程处于了冻结状态，就不会读到标记，线程也就不会结束。当没有指定的方式让冻结的线程恢复到运行状态时，就需要对冻结进行清除，强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束。

 ---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

详细请查看：<a href="http://edu.csdn.net" target="blank">http://edu.csdn.net</a>