黑马程序员————多线程1（day11）

最新推荐文章于 2013-09-01 15:16:58 发布

AIxxx

最新推荐文章于 2013-09-01 15:16:58 发布

阅读量528

点赞数

分类专栏： Java笔记文章标签：黑马程序员

本文链接：https://blog.csdn.net/u010201862/article/details/10718899

版权

Java笔记专栏收录该内容

27 篇文章 0 订阅

订阅专栏

----------------------ASP.Net+Android+IOS开发----------------------期待与您交流！

多线程1

l 多线程 – 概述

l 创建线程 – 继承Thread类

l 创建线程 - 实现Runnable接口

l 创建线程 – run和start特点

l 线程的状态

l 多线程的安全问题

l 多线程同步代码块

l 多线程 – 同步函数的所示this

l 多线程 – 死锁

多线程 –概述

Java是少数的几种支持“多线程”的语言之一。大多数的程序语言智能循序运行单独的一个程序块，但无法同时运行不同的多个程序块。Java的“多线程”恰可弥补这个缺憾，它可以让不同的程序块一起运行，如此一来就可让程序运行得更为顺畅，同时也可达到多任务处理的目的。

进程与线程

进程的特征是：

1. 一个进程就是一个执行中的程序，而每一个进程都有自己独立的一块内存空间，一组系统资源。在进程概念中，每一个进程的内部数据和状态都是完全独立的。

2. 创建并执行一个进程的系统开像是比较大的。

3. 进程是程序的一次执行过程，是系统运行程序的基本单位。

线程的特征是：

1. 在Java中，程序通过流控制来执行程序流。程序中单个顺序的流控制称为线程。

2. 多线程指的是在单个进程中可以同时运行多个不同的线程，执行不同的任务。多线程意味着一个程序的多行语句可以看上去几乎同时运行。

简单来说：

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

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

Java虚拟机启动的时候会有一个进程java.exe

该进程中至少一个线程负责java程序的执行。而且这个线程运行的代码存在于main方法中。该线程称之为主线程。

扩展：

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

创建线程 –继承Thread类

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

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

创建线程的第一种方式：继承Thread类。

步骤：

1. 定义类继承Thread。

2. 覆写Thread类中的run()方法。目的：将自定义代码存储在run()方法，让线程运行。

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

例：

//继承Thread类实现多线程
class Demo extends Thread{
	//覆写run()方法
	public void run(){
		for (int i = 0; i < 60; i++) {
			System.out.println("线程执行" + i);
		}
	}
}

public class ThreadDemo{
	public static void main(String[] args){
		Demo d = new Demo();
		d.start();//启动线程，JVM自动调用Thread类中的run()方法。这时调用的是d的run()方法
		//d.run();仅仅是对象调用方法。而线程创建了，并没有运行。这里不能这样写。
		for (int i = 0; i < 60; i++) {
			System.out.println("hello world" + i);
		}
	}
}

上段程序运行后，发现运行结果每一次都不同：

因为多个线程都获取cpu的执行权。Cpu执行到谁，谁就运行。明确一点，在某一个时刻，只能有一个程序在运行（多核除外）。cpu在作者快速的切换，以达到看上去是同时运行的效果。我们可以形象把多线程的运行行为在互相抢夺cpu的执行权。

这就是多线程的一个特性：

随机性。谁抢到谁执行，至于执行多长，cpu说的算。

创建线程 – run和start特点

为什么要覆写run方法呢？

Thread类用于描述线程。该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法。

也就是说Thread类中的run方法，用于存储线程要运行的代码。

线程的状态

在给定时间点上，一个线程只能处于一种状态。

1. new:至今尚未启动的线程处于这种状态。

2. Runnable：正在Java虚拟机中执行的线程处于这种状态。

3. Blocked:受阻塞并等待某个监视器锁的线程处于这种状态。

4. Waiting:无限期地等待另一个线程来执行某一特定操作的线程处于这种状态。

5. Time_waiting:等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。

6. Terminated:已退出的线程处于这种状态。

线程都有自己的默认名称：

Thread-编号该编号从0开始。获取方法：Thread.currentThread().getName();

currentThread():获取当前线程对象。

getName():获取线程名称。

创建线程 -实现Runnable接口

步骤：

1. 定义类实现Runnable接口

2. 覆写Runnable接口中的run方法：将线程要运行的代码存在在run方法中。

3. 通过 Thread类建立线程对象。

4. 将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。为什么要将Runnable接口的子类对象传递给Thread的构造函数。因为，自定义run方法所属的对象是Runnable接口的子类对象。所以要让线程去指定指定对象的run方法，就必须明确该run方法所属的对象。

5. 调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

例：

class Demo1 implements Runnable{
	//覆写run()方法
	public void run(){
		for (int i = 0; i < 60; i++) {
			System.out.println("线程执行" + i);
		}
	}
}

public class RunnableDemo{
	public static void main(String[] args){
		Demo1 d = new Demo1();
		Thread t1 = new Thread(d);
		Thread t2 = new Thread(d);
		Thread t3 = new Thread(d);
		t1.start();
		t2.start();
		t3.start();
	}
}

实现方式和继承方式有什么区别呢？

实现方式好处：避免了单继承的局限性。

在定义线程时，建议使用实现方式。

两种方式的区别：

继承Thread：线程代码存放在Thread子类run方法中。

实现Runnbale:线程代码存放在接口子类的run方法中。

多线程的安全问题

例：

class Ticket implements Runnable{
	private int tick = 100;
	public void run(){
		while(true){
			if(tick > 0){
				try {
					Thread.sleep(10);
				} catch (Exception e) {
					// TODO: handle exception
				}
				System.out.println(Thread.currentThread().getName() + "..." + tick--);
			}
		}
	}
}

public class TicketDemo{
	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();
	}
}

通过上段代码分析，发现，打印出0，-1，-2等错票。

多线程的运行出现了安全问题。

问题的原因：

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

解决办法：

对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。

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

Synchronized(对象){

需要被同步的代码

}

讲上述代码修改：

class Ticket implements Runnable{
	private int tick = 100;
	Object obj = new Object();
	public void run(){
		while(true){
			synchronized (obj) {
				if(tick > 0){
					try {
						Thread.sleep(10);
					} catch (Exception e) {
						// TODO: handle exception
					}
					System.out.println(Thread.currentThread().getName() + "..." + tick--);
				}
			}
		}
	}
}

public class TicketDemo{
	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();
	}
}

多线程同步代码块

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

火车上的卫生间----经典同步例子

同步的前提：

1. 必须要有两个或者两个以上的线程。

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

必须保证同步中只能有一个线程在运行。

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

弊端：多个线程需要判断锁，较为消耗资源。

多线程 –同步函数的所示this

同步函数用的是哪一个锁呢？

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

例：

class Ticket implements Runnable{
	private int tick = 100;
	Object obj = new Object();
	boolean flag = true;
	public void run(){
		if(flag){
			while(true){
				synchronized (this) {
					if(tick > 0){
						try {
							Thread.sleep(10);
						} catch (Exception e) {
							// TODO: handle exception
						}
						System.out.println(Thread.currentThread().getName() + "...code" + tick--);
					}
				}
			}
		}else
			while(true)
				show();
	}
	
	public synchronized void show(){
		if(tick > 0){
			try {
				Thread.sleep(10);
			} catch (Exception e) {
				// TODO: handle exception
			}
			System.out.println(Thread.currentThread().getName() + "...show" + tick--);
		}
	}
}

public class TicketDemo{
	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 (Exception e) {
			// TODO: handle exception
		}
		t.flag = false;
		t2.start();
	}
}

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

通过验证，发现不在是 this，因为静态方法中不可以定义this。

静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象：类名.class 该对象的类型是Class。

静态的同步方法，使用的锁是该方法所在的字节码文件对象。

多线程 –死锁

一旦有多个进程，且他们都要争用对多个锁的独占访问，那么久有可能发生死锁。如果有一组进程或线程，其中每个都在等待一个只有其他进程或线程才可以进行的操作，那么就称它们被死锁了。

死锁：同步中嵌套同步。

例：

class Test implements Runnable{
	private boolean flag;
	Test(boolean flag){
		this.flag = flag;
	}
	
	public void run(){
		if(flag){
			synchronized (MyLock.locka) {
				System.out.println("if locka");
				synchronized (MyLock.lockb) {
					System.out.println("if lockb");
				}
			}
		}else{
			synchronized (MyLock.lockb) {
				System.out.println("else lockb");
				synchronized (MyLock.locka) {
					System.out.println("else locka");
				}
			}
		}
	}
}

class MyLock{
	static Object locka = new Object();
	static Object lockb = new Object();
}

public class DeadLockDemo{
	public static void main(String[] args){
		Thread t1 = new Thread(new Test(true));
		Thread t2 = new Thread(new Test(false));
		t1.start();
		t2.start();
	}
}

----------------------ASP.Net+Android+IOS开发----------------------期待与您交流！

详情请查看：http://edu.csdn.net

AIxxx

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员————多线程1（day11）

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ---------------------- 多线程1l 多线程 – 概述l 创建线程 – 继承Thread类l 创建线程 - 实现Runnable接口l 创建线程 – run和start特点l 线程的状态l
复制链接

扫一扫