Java中多线程原理详解

Java是少数的集中支持多线程的语言之一，大多数的语言智能运行单独的一个程序块，无法同时运行不同的多个程序块，Java的多线程机制弥补了这个缺憾，它可以让不同的程序块一起运行，这样可以让程序运行更加顺畅，同时也达到了多任务处理的目的。

　　一、线程和进程的概念

　　现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。

　　进程是程序的一个动态执行过程，是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在 Windows系统中，一个运行的exe就是一个进程。线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程的内存。“同时”执行是人的感觉，在线程之间实际上轮换执行。

　　二、Java中线程的实现

　　在Java中想实现多线程有两种手段，一种是集成Thread类，另一种就是实现Runnable接口。下面看继承自Thread类线程的创建原理。

　　首先定义一个线程类，该类必须继承自Thread类，同时必须明确的覆写run()方法，如：

class MyThread extends Thread{

　　public void run(){ //覆写Thread类中的run方法此方法是线程中

　　线程主体;

　　}

｝

然后定义一个主类，实例化线程类的对象，发动启动线程的命令，如：

public class ThreadText{

　　public stataic void main(String args[]){

　　MyThread m1=new MyThread();//实例化对象

　　m1.start();//启动多线程

　　}

}

实现Runnable接口，首先定义一个线程类继承自Runnable接口，如：

class MyThread implements Runnable{

　　public void run(){ //覆写Runnable接口中的run方法

　　线程主体;

　　}

｝

然后定义一个主类，实例化线程类的对象，发动启动线程的命令，如：

public class ThreadText{

　　public stataic void main(String args[]){

　　MyThread m1=new MyThread();//实例化Runnable子类对象

　　Thread t1=new Thread(m1);//实例化Thread类对象

　　t1.start();//启动多线程

　　}

}

三、线程的几种状态

　　在Java当中，线程通常都有五种状态，创建、就绪、运行、阻塞和死亡。

　　第一是创建状态。在生成线程对象，并没有调用该对象的start方法，这是线程处于创建状态。

　　第二是就绪状态。当调用了线程对象的start方法之后，该线程就进入了就绪状态，但是此时线程调度程序还没有把该线程设置为当前线程，此时处于就绪状态。在线程运行之后，从等待或者睡眠中回来之后，也会处于就绪状态。

　　第三是运行状态。线程调度程序将处于就绪状态的线程设置为当前线程，此时线程就进入了运行状态，开始运行run函数当中的代码。

　　第四是阻塞状态。线程正在运行的时候，被暂停，通常是为了等待某个时间的发生(比如说某项资源就绪)之后再继续运行。sleep,suspend，wait等方法都可以导致线程阻塞。

　　第五是死亡状态。如果一个线程的run方法执行结束或者调用stop方法后，该线程就会死亡。对于已经死亡的线程，无法再使用start方法令其进入就绪。

多线程安全问题的解决方案：

首先我们得明白两个概念：同步 和 互斥；



只要 保证一个线程在执行多条操作共享数据的语句时，其他线程不能参与运算即可。

当该线程都执行完后，其他线程才可以执行这些语句。

Java为我们提供了具体的解决方案——同步代码块。

synchronized（对象）{ // 对象可以是 任意的对象

//需要被同步的代码；

}

在上个例子中加入synchronized 后，代码如下：

[java] view plain copy

print?

package chapter1502;

public class Ticket1 implements Runnable{

private int tickets = 100;

private Object obj = new Object();

//线程任务

public void run(){

while(true){

synchronized(obj){ //加锁

if(tickets>0){

try {

Thread.sleep(10);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + " " + tickets--);

}

}

}

}

}

至此，就解决了 上篇所提及的 线程安全问题！

下面介绍三个问题：同步的原理，同步的好处,弊端 ，同步的前提

同步的原理：其实就是将需要同步的代码进行封装，并在该代码上加了一个锁。

同步的好处，弊端：

好处：使多线程处于能够安全的运行。

弊端：在加了多线程之后，多个线程在对锁申请使用权的时候，会使CPU不断的切换，，这样做，会引起性能的降低。

同步的前提：

1. 必须要保证在同步中有多个线程。 因为同步中只有一个线程该同步是没有意义的。

2. 必须要保证多个线程在同步中使用的是同一个锁。这是才称为 多个线程被同步了！

关于同步的前提，请看下例代码：

[java] view plain copy

print?

package chapter1502;

public class Ticket1 implements Runnable{

private int tickets = 100;

//线程任务

public void run(){

Object obj = new Object();

while(true){

synchronized(obj){ //加锁

if(tickets>0){

try {

Thread.sleep(10);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + " " + tickets--);

}

}

}

}

}

[java] view plain copy

print?

public class SaleTicket2 {

public static void main(String[] args) {

//任务对象

Ticket1 t1 = new Ticket1();

//线程对象

Thread td1 = new Thread(t1);

Thread td2 = new Thread(t1);

Thread td3 = new Thread(t1);

Thread td4 = new Thread(t1);

//开启线程

td1.start();

td2.start();

td3.start();

td4.start();

}

}

运行结果为：



运行后发现，即使加了同步 ，加了锁，然而问题依旧，这是为什么呢？

在主函数中：

//任务对象
Ticket1 t1 = new Ticket1();
//线程对象
Thread td1 = new Thread(t1);
Thread td2 = new Thread(t1);
Thread td3 = new Thread(t1);
Thread td4 = new Thread(t1);

//开启线程
td1.start();
td2.start();
td3.start();
td4.start();

当我们在主函数中，创建了线程对象后，注意，每个run()方法中，都有一个锁，因为他们自己用的自己的锁，所以 同步就相当于没加，所以会再次出现这样的问题，故而，当我们在为同步加锁的时候，一定得保证，加的锁是同一把锁。

同步函数：函数本身没有同步性，当我们为他加上 synchronized标记后，他也就具备了同步性。

上述代码经过修改后：

[java] view plain copy

print?

class Ticket implements Runnable

{

private int num = 100;

private Object obj = new Object();

public void run()

{

while(true)

{

show();

}

}

//同步函数

public synchronized void show()

{

if(num>0)

{

try{Thread.sleep(10);}catch(InterruptedException e){}

System.out.println(Thread.currentThread().getName()+".....sale....."+num--);

}

}

}

class TicketDemo3

{

public static void main(String[] args)

{

Ticket t = new Ticket();

//创建线程对象。

Thread t1 = new Thread(t);

Thread t2 = new Thread(t);

Thread t3 = new Thread(t);

Thread t4 = new Thread(t);

t1.start();

t2.start();

t3.start();

t4.start();

}

}

那么，同样是同步，同步函数和同步代码块的区别：

1. 同步函数比同步代码块 写法简单。

2. 同步函数使用的锁是 this . 同步代码块使用的是 任意指定的对象。

下面主要介绍一下，锁——同步代码块，同步函数，静态同步函数使用的锁：

1. 同步代码块使用的锁是：任意的对象；

2. 同步函数使用的锁是： this , this代表当前对象的引用。

3. 静态——当一个类被加载进内存以后，在我们还没有创建对象的时候，已经有对象了Xx.class。

静态随着类的加载而加载，这时内存中存储的对象至少有一个 就是该类字节码文件对象。

这个对象的表示方式： 类名.class

[java] view plain copy

print?

class StaticLockDemo

{

public static void main(String[] args)

{

Ticket t = new Ticket();

//创建线程对象。

Thread t1 = new Thread(t);

Thread t2 = new Thread(t);

t1.start();

try{Thread.sleep(10);}catch(InterruptedException e){}

//在开启了t1后，将标记置为false。

t.setFlag();

t2.start();

}

}

class Ticket implements Runnable

{

private static int num = 200;

private boolean flag = true;

public void run()

{

if(flag)//为true就执行同步代码块。

while(true)

{

synchronized(Ticket.class)

{

if(num>0)

{

try{Thread.sleep(10);}catch(InterruptedException e){}

System.out.println(Thread.currentThread().getName()+".....code.........."+num--);

}

}

}

else//为false就执行同步函数。

while(true)

{

show();

}

}

/*

将标记改为false。

*/

public void setFlag()

{

flag = false;

}

public static synchronized void show()

{

if(num>0)

{

try{Thread.sleep(10);}catch(InterruptedException e){}

System.out.println(Thread.currentThread().getName()+"............func....."+num--);

}

}

}

class StaticLockDemo

{

public static void main(String[] args)

{

Ticket t = new Ticket();

//创建线程对象。

Thread t1 = new Thread(t);

Thread t2 = new Thread(t);

t1.start();

try{Thread.sleep(10);}catch(InterruptedException e){}

//在开启了t1后，将标记置为false。

t.setFlag();

t2.start();

}

}

死锁：

指多个进程or 线程在运行过程中因争夺资源而造成的一种僵局，当线程 处于 这种僵态是，若无外力作用，他们将无法再向前推进。

最常见的死锁情况，同步的嵌套：

同步中还有同步，两个同步用的不是一个锁。

我们应当，尽量避免同步嵌套的情况。

如下所示：

[java] view plain copy

print?

public class Clock {

public static Clock locka = new Clock();

public static Clock lockb = new Clock();

}

public class DeadLock implements Runnable {

private boolean flag;

public DeadLock(boolean flag){

this.flag = flag;

}

@Override

public void run() {

if(flag){

while(true){

synchronized(Clock.locka){

System.out.println(".................if locka");

synchronized(Clock.lockb){

System.out.println(".................if lockb");

}

}

}

}

else{

while(true){

synchronized(Clock.lockb){

System.out.println("-------------------------else lockb");

synchronized(Clock.locka){

System.out.println("----------------------else locka");

}

}

}

}

}

}

public class DeadLockTest {

public static void main(String[] args) {

DeadLock d1 = new DeadLock(true);

DeadLock d2 = new DeadLock(false);

Thread t1 = new Thread(d1);

Thread t2 = new Thread(d2);

t1.start();

t2.start();

}

}

上例中，当先线程1 拿到 Clock.locka , 线程2 拿到 Clock.lockb， 但 此时，线程1 需要 Clock.lockb 来继续运行，线程2 需要 Clock.locka 来继续运行，他们互不想让，就造成了死锁的状况。