使用多线程

Posted on | In | Visitors:

一个进程正在运行时至少会有1个线程的运行，这种情况在Java中也是存在的。

每一个进程至少有一个线程，这些线程都是在后台默默地执行，比如调用public static void main（）的线程就是这样的，它是由JVM创建的。示例如下：
代码清单1 main方法

1
2
3
4
5
6
7
public class callMainMethodMainThread {
	public static void main(String[] args) {
	System.out.println("当前的线程名："+Thread.currentThread().getName());
	}
}

运行结果如图1所示。



图1 运行结果

控制台输出线程名为main，但是main与mian方法仅仅是名字相同而言。

常见实现多线程编程的方式主要有两种，一种是继承Thread类，另一个是实现Runnable接口。
Thread类的结构如下：
public class Thread implements Runnable
从上面的源代码中可以发现，Thread类实现了Runnable接口，它们之间具有多态关系。
使用继承Thread类的方式创建新线程时，最大的局限就是不支持多继承。因为Java语言的特点就是单根继承，所以为了支持多继承，完全可以实现Runnable接口的方式，一边实现一边继承。但用着两种方式创建的线程在工作时的性质是一样的，没有本质区别。

继承Thread类

继承自Thread，重写run方法。
代码清单2 继承Thread类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class MyThread extends Thread {
	@Override
	public void run(){
		super.run();
		System.out.println("MyThread");
	}
}
public class MyThreadRun {
	public static void main(String[] args) {
        MyThread myThread=new MyThread();
        myThread.start();
        System.out.println("运行结束!");
	}
}

运行结果如图2所示。



图2 myThread运行结果

从运行结果来看，MyThread.java类中的run方法执行时间比较晚，这也说明在使用多线程技术时，代码的运行结果与代码执行顺序或调用顺序无关。
注意：如果重复调用start方法调用start（）方法，则会出现Exception in thread "main" MyThread java.lang.IllegalThreadStateException 异常。
演示线程的随机性，如代码清单3所示。
代码清单3 randomThread

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class RandomThread extends Thread {
	@Override
	public void run(){
		try{
			for(int i=0;i<10;i++){
				int  time=(int)(Math.random()*1000);
				Thread.sleep(time);
				System.out.println("run="+Thread.currentThread().getName());
			}
		}catch(InterruptedException e){
			e.printStackTrace();
		}
	}
}
public class RandomThreadTest {
	public static void main(String[] args) {
		try {
			RandomThread thread = new RandomThread();
			thread.setName("myThread");
			thread.start();
			for (int i = 0; i < 10; i++) {
				int time = (int) (Math.random() * 1000);
				Thread.sleep(time);
				System.out.println("main=" + Thread.currentThread().getName());
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

在代码中，为了展现出线程具有随机性，所以使用随机数的形式来使线程得到挂起的效果，从而表现出CPU执行哪个线程具有不确定性。
Thread类中的start()方法通知“线程规划器”此线程已经准备就绪，等待调用线程对象的run()方法。这个过程其实就是让系统安排一个时间来调用Thread中的run方法，也就是使线程得到运行，启动线程，具有异步执行的效果。如果调用代码thread.run()就不是异步执行了，而是同步，那么此线程对象并不交给“线程规划器”来进行处理，而是由main主线来调用run()方法，也就是必须等run()方法中的代码执行完成才可以执行后面的代码。
异步的方法运行效果如图3所示。



图3 随机被执行的线程

另外还需要注意一下，执行start()方法的顺序不代表线程启动的顺序。如代码清单4所示。
代码清单4 RankThread

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public class RankThread extends Thread {
	private int i;
	public RankThread(int i){
		super();
		this.i=i;
	}
	@Override
	public void run(){
		System.out.println(i);
	}
}
public class RankThreadTest {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		RankThread t1 = new RankThread(1);
		RankThread t2 = new RankThread(2);
		RankThread t3 = new RankThread(3);
		RankThread t4 = new RankThread(4);
		RankThread t5 = new RankThread(5);
		RankThread t6 = new RankThread(6);
		RankThread t7 = new RankThread(7);
		RankThread t8 = new RankThread(8);
		RankThread t9 = new RankThread(9);
		RankThread t10 = new RankThread(10);
		RankThread t11 = new RankThread(11);
		RankThread t12 = new RankThread(12);
		RankThread t13 = new RankThread(13);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		t5.start();
		t6.start();
		t7.start();
		t8.start();
		t9.start();
		t10.start();
		t11.start();
		t12.start();
		t13.start();
	}
}

线程启动顺序与start()执行顺序无关，如下图。



图4 线程启动顺序与start()执行顺序无关

实现Runnable接口

如果要创建的线程类已经有一个父类了，这时就不能再继承自Thread类了，因为Java不支持多继承，所以就需要实现Runnable接口来应对这种情况。
代码清单5 MyRunnable实现Runnable接口

1
2
3
4
5
6
7
8
public class MyRunnable implements Runnable {
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("运行中！");
	}
}

如何使用MyRunnable.Java类呢？这就要看一下Thread.java的构造函数了如图5所示。



图5 Thread构造函数

构造函数Thread（Runnable target）可以传递Runnable接口，说明构造函数支持传入一个Runnable接口的对象。运行类代码如下。
代码清单6 运行类

1
2
3
4
5
6
7
8
9
10
public class MyRunnableTest {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MyRunnable runnable=new MyRunnable();
		Thread thread=new Thread(runnable);
		thread.start();
		System.out.println("运行结束！");
	}
}

运行结果如图6所示。



图6 运行结果

构造函数Thread（Runnable target）不光可以传入Runnable接口对象，还可以传入一个Thread类的对象，这样做完全可以将一个Thread对象中的run方法交由其他的线程进行调用。

实例变量与线程安全

自定义线程类中的实例变量针对其他线程可以有共享与不共享之分，这在多个线程之间进行交互时是很重要的一个技术点。

不共享数据情况

不共享数据的情况如图7所示。



图7 不共享数据

代码清单7 不共享情况

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class UnshareThread extends Thread {
	private int count = 5;
	public UnshareThread(String name) {
		super();
		this.setName(name);
	}
	public void run() {
		super.run();
		while (count > 0) {
			count--;
			System.out.println("由" + this.currentThread().getName() + "计算，count=" + count);
		}
	}
}
public class NushareThreadRun {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		UnshareThread a=new UnshareThread("A");
		UnshareThread b=new UnshareThread("B");
		UnshareThread c=new UnshareThread("C");
		a.start();
		b.start();
		c.start();
	}
}

运行结果如图8所示，每个线程都有各自的count变量，自己减少自己的count变量的值。这样的情况就是变量不共享，此例并不存在多个线程访问同一个实例变量的情况。



图8 不共享数据运行结果

共享数据的情况

共享数据的情况如图9所示。



图9 共享数据

共享数据就是多个线程可以访问同一个变量，代码如下。
代码清单8 共享情况

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class ShareThread extends Thread {
	private int count=5;
	public void run(){
		super.run();
		count--;
		//此示例不要用for语句，因为使用后其他线程就得不到运行的机会了
		//一直由一个线程进行减法运算
		System.out.println("由" + this.currentThread().getName() + "计算，count=" + count);
	}
}
public class ShareThreadRun {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ShareThread thread=new ShareThread();
		Thread a=new Thread(thread,"A");
		Thread b=new Thread(thread,"B");
		Thread c=new Thread(thread,"C");
		Thread d=new Thread(thread,"D");
		Thread e=new Thread(thread,"E");
		a.start();
		b.start();
		c.start();
		d.start();
		e.start();
	}
}

共享数据运行结果如图10所示。



图10 共享数据运行结果

从图10可以看到线程D和E打印出的count都是0，说明D和E同时对count进行处理，产生了“非线程安全”问题。而我们想要得到的打印结果却不是重复的，而是依次递减的。
在某些JVM中，i–的操作要分成如下3步：

  1. 取得原有i值
  2. 计算i-1
  3. 对i进行赋值

在这3个步骤中，如果有多个线程同时访问，那么一定会出现非线程安全问题。

典型案例

5个销售员卖同一个货物，必须在每一个销售员卖完后其他销售员才可以在新的剩余物品数上减1操作。这时需要使多个线程之间进行同步，也就是用按顺序排队的方式进行减1操作。更改上面代码可得如下。
代码清单9 SynchronizedThread

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class SynchronizedThread extends Thread {
	private int count = 5;
	synchronized public void run() {
		super.run();
		count--;
		System.out.println("由" + this.currentThread().getName() + "计算，count=" + count);
	}
}
public class SynchronizedThreadRun {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		SynchronizedThread thread=new SynchronizedThread();
		Thread a=new Thread(thread,"A");
		Thread b=new Thread(thread,"B");
		Thread c=new Thread(thread,"C");
		Thread d=new Thread(thread,"D");
		Thread e=new Thread(thread,"E");
		a.start();
		b.start();
		c.start();
		d.start();
		e.start();
	}
}

共享数据运行结果如图11所示。



图11 共享数据运行结果

通过run方法前加入synchronized关键字，使多个线程在执行run方法时，以排队的方式进行处理。当一个线程调用run前，先判断run方法有么有上锁，如果上锁，说明其他方法正在调用run方法，必须等待其他线程对run方法调用结束后才可以执行run方法。这样也就实现了排队调用run方法的目的，也就达到了按顺序对count变量减1的效果了。synchronized可以在任意对象及方法上加锁，而加锁的这段代码称为“互斥区”或“临界区”。
当一个线程想要执行同步方法里面的代码时，线程首先尝试去拿这把锁，如果能够拿到这把锁，那么这个线程就可以执行synchronized里面的代码。如果不能拿到这把锁，那么这个线程就会不断地尝试拿这把锁，直到能够拿到为止，而且是有多个线程同时去争抢这把锁。

非线程安全

非安全安全主要是多个线程对同一个对象中的同一个实例变量进行操作时会出现值被更改、值不同步的情况，进而影响程序的执行流程。下面为一个如何解决“非线程安全”的问题。
代码清单10 非线程安全

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
//本类模拟成一个Servlet组件
public class LoginServlet {
	private static String usernameRef;
	private static String passwordRef;
	//synchronized public static void doPost(String username, String password) {
	public static void doPost(String username, String password) {
		try {
			usernameRef = username;
			if (username.equals("a")) {
				Thread.sleep(5000);
			}
			passwordRef = password;
			System.out.println("username=" + usernameRef + " password=" + password);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}
public class ALogin extends Thread {
	public void run(){
		LoginServlet.doPost("a", "aa");
	}
}
public class BLogin extends Thread {
	public void run(){
		LoginServlet.doPost("b", "bb");
	}
}
public class LoginServletRun {
	public static void main(String[] args) {
		ALogin a=new ALogin();
		a.start();
		BLogin b=new BLogin();
		b.start();
	}
}

非线程安全运行结果如图12所示。



图12 非线程安全运行结果

解决这个“非线程安全”的方法也就是使用synchronized关键字。代码如代码清单10所示，选用注释掉那部分代码。



图13 排队进入运行结果

留意i–与System.out.println()的异常

本节将通过程序案例细化一下println方法与i++联合使用时“有可能”出现的另外一种异常情况，并说明其原因。
代码清单11 println方法与i++联合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class SameNum extends Thread {
	private int i=5;
	public void run(){
		System.out.println("i="+(i--)+" threadName="+ Thread.currentThread().getName());
	  /*
		*主要：代码i--由前面项目中单独一行改成在当前项目中在println()方法中直接进行打印
	    */
	}
}
public class SameNumRun {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		SameNum thread=new SameNum();
		Thread a=new Thread(thread);
		Thread b=new Thread(thread);
		Thread c=new Thread(thread);
		Thread d=new Thread(thread);
		Thread e=new Thread(thread);
		a.start();
		b.start();
		c.start();
		d.start();
		e.start();
	}
}

线程运行后根据概率还是会出现非线程安全问题，如图14所示。



图14 出现非线程安全

本实验的测试目的是：虽然println（）方法在内部都是同步的，但是i–的操作却是在进入println（）之前发生的，所以有发生非线程安全问题的概率，如图15所示。



图15 println内部同步

所以，为了防止发生非线程安全问题，还是应继续使用同步方法。

Java多线程编程核心技术源代码。

Adhere to the original technology to share, your support will encourage me to continue to create!