JAVA学习（九）：JAVA多线程编程

转载 于 2015-09-06 08:08:00 发布 · 89 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://yq.aliyun.com/articles/31101
文章标签：

#java #操作系统

本文深入探讨JAVA多线程编程技巧，涵盖进程与线程的区别、线程的两种实现方式（继承Thread类与实现Runnable接口）、线程的常用方法（如join(), sleep(), yield()等）、线程优先级设置、线程同步机制（同步代码块与方法），以及线程的生命周期。

本文详细解释JAVA多线程编程，首先对进程和线程做了区别，其次介绍线程的两种实现方式，即继承Thread类和实现Runnable接口，然后讨论了线程常用的方法和优先级，最后介绍了线程的同步和死锁以及线程的生命周期。

 

1、进程与线程的区别与联系


进程：是应用程序的运行实例，是应用程序的一次动态执行。进程是由进程控制块、程序段和数据段3部分组成的。进程是操作系统进行资源分配的单位。

线程：是进程中的一个实体，其本身依靠程序进行运行，是程序中的顺序控制流，只能使用分配给程序的资源和环境。线程是被系统独立调度和分派的基本单位。

单线程：程序中只存在一个线程，即主线程。

多线程：在一个程序中运行多个任务，其目的是为了更好地使用CPU资源。

进程与线程的区别：

（1）、一个程序至少拥有一个进程，一个进程至少有一个线程；

（2）、进程在执行过程中拥有独立的内存单元，而多个线程共享进程所拥有的内存；

（3）、进程可以独立运行，但是线程不可以独立运行，必须依存在进程中，由使用该进程的应用程序提供多个线程执行控制。

 

2、线程的两种Java实现方式


Java中线程的实现类是Thread类，该类位于java.lang包中。Thread类不可直接实例化，必须通过派生Thread类的子类来操作线程。

JAVA线程的实现共两种方式，即：

——继承Thread类

——实现Runnable接口

我们知道Thread类不可直接实例化，必须通过派生Thread类的子类来操作线程，因此这两种方法都必须通过派生子类并重写run()方法来实现线程。


（1）、继承Thread类


首先通过继承Thread类来派生子类，并重写run()方法，示例代码如下：

package fred.hqu.thread;

public class MyThread extends Thread{

	private String name;
	
	//构造方法
	public MyThread(String name) {
		this.name=name;
	}
	
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(name+":"+i);
		}
		super.run();
	}
}

接着，实例化，最后启动线程，示例代码如下：

package fred.hqu.thread;

public class ThreadDemo01 {

	public static void main(String[] args) {

		//实例化
		MyThread t1 = new MyThread("A");
		MyThread t2 = new MyThread("B");
		
//		t1.run();
//		t2.run();
		
		//线程的启动是通过start()方法
		t1.start();
		t2.start();			
		
	}

}

（2）、实现Runnable接口


首先通过实现Runnable接口来派生子类，并重写run()方法，示例代码如下：

package fred.hqu.thread;

public class MyRunnable implements Runnable{
	
	private String name;
	
	public MyRunnable(String name) {
		this.name=name;
	}
	
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(name+":"+i);
		}
		
	}

}

接着，实例化，最后启动线程，示例代码如下：

package fred.hqu.thread;

public class ThreadDemo02 {

	public static void main(String[] args) {
		MyRunnable r1 = new MyRunnable("A");
		MyRunnable r2 = new MyRunnable("B");
		
		Thread t1 = new Thread(r1);
		Thread t2 = new Thread(r2);

		//线程启动
		t1.start();
		t2.start();
	}

}

3、线程的5大状态


线程共包括5个主要的状态，即：

——创建状态：准备好了一个多线程的对象

——就绪状态：调用了start()方法，等待CPU进行调度

——运行状态：执行run()方法

——阻塞状态：暂时停止执行，可能将资源交给其他线程使用

——终止状态：即死亡状态，也就是线程销毁。

 

4、线程的常用方法详解


线程的常用方法基本上都在Thread类中，所以大部分都要通过Thread类进行调用。常用的方法主要包括以下几种：

（1）、取得当前线程对象

currentThread()

（2）、取得线程名称

getName()

（3）、判断线程是否启动

isAlive()

（4）、线程的强行运行

join()

（5）、线程的休眠

sleep()

（6）、线程的礼让

yield()

 

示例代码如下：

package fred.hqu.thread;

//创建线程
class ThreadDemo extends Thread{
	
	private String name;
	
	public ThreadDemo(String name) {
		this.name = name;
	}
	
	@Override
	public void run() {
//		//取得当前线程的对象
//		System.out.println("当前线程的对象："+Thread.currentThread());
//		//取得当前线程的名称
//		System.out.println("当前线程的名称："+Thread.currentThread().getName());
		for (int i = 0; i < 50; i++) {
//			//线程的休眠
//			try {
//				Thread.sleep(1000);
//			} catch (InterruptedException e) {
//				// TODO Auto-generated catch block
//				e.printStackTrace();
//			}
			System.out.println(name+":"+i);
			//线程礼让
			if(i==10){
				System.out.println("线程礼让");
				Thread.yield();
			}
		}
	}
}

public class ThreadDemo03 {

	public static void main(String[] args) {
		//实例化
		ThreadDemo t1 = new ThreadDemo("A");
		ThreadDemo t2 = new ThreadDemo("B");
		
//		//判断线程是否启动
//		System.out.println(t1.isAlive());
//		System.out.println(t2.isAlive());
//		
		//线程启动
		t1.start();
		t2.start();
//			
//		//判断线程是否启动
//		System.out.println(t1.isAlive());
//		System.out.println(t2.isAlive());

//		ThreadDemo t = new ThreadDemo("A");
//		t.start();
		
//		//线程的强行运行
//		for (int i = 0; i < 50; i++) {
//			if(i>25){
//				try {
//					t.join();
//				} catch (InterruptedException e) {
//					// TODO Auto-generated catch block
//					e.printStackTrace();
//				}
//			}
//			System.out.println("主线程："+i);
//		}
	}

}

5、线程的优先级介绍


线程的优先级分为3大类，即：

——MIN_PRIORITY：1

——MAX_PRIORITY：10

——NORM_PRIORITY：5

示例代码如下：

package fred.hqu.thread;

class MyRun implements Runnable{
	
	public MyRun() {
		// TODO Auto-generated constructor stub
	}
	
	@Override
	public void run() {
		for (int i = 0; i < 5; i++) {
			try {
				Thread.sleep(3000);
				System.out.println(Thread.currentThread().getName()+":"+i);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
	}
}

public class ThreadDemo04 {

	public static void main(String[] args) {
		MyRun r1 = new MyRun();
		MyRun r2 = new MyRun();
		MyRun r3 = new MyRun();
		
		Thread t1 = new Thread(r1);
		Thread t2 = new Thread(r2);
		Thread t3 = new Thread(r3);
		
		//设置优先级
		t1.setPriority(Thread.MIN_PRIORITY);
		t2.setPriority(Thread.MAX_PRIORITY);
		t3.setPriority(Thread.NORM_PRIORITY);
		
		t1.start();
		t2.start();
		t3.start();

	}

}



6、“线程同步”解析


为了防止资源的访问冲突，Java提供了进程的同步机制，通过同步和死锁可以有效控制进程的资源分配问题。


（1）、同步代码块


在代码块上加上“synchronized”关键字，则此代码块就称为同步代码块。

同步代码块格式为：

synchronized （同步对象）{
需要同步的代码块；
}

示例代码如下：

package fred.hqu.thread;

class MyRunDemo implements Runnable{
	
	private int ticket=5;
	
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			synchronized (this) {
				if(ticket>0){
					try {
						Thread.sleep(500);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println("车票："+ticket--);
				}
			}
		}
		
	}
}

public class ThreadDemo05 {

	public static void main(String[] args) {
		MyRunDemo m = new MyRunDemo();
		Thread t1 = new Thread(m);
		Thread t2 = new Thread(m);
		Thread t3 = new Thread(m);
		
		t1.start();
		t2.start();
		t3.start();

	}

}


（2）、同步方法


除了代码块可以同步，方法也是可以同步的。

方法同步格式为：

synchronized void 方法名称（） {}

示例代码如下：

package fred.hqu.thread;

class MyRunDemo06 implements Runnable{
	
	private int ticket=5;
	
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			tell();
		}
		
	}
	public synchronized void tell(){
		if(ticket>0){
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("车票："+ticket--);
		}
	}
}

public class ThreadDemo06 {

	public static void main(String[] args) {
		MyRunDemo06 m = new MyRunDemo06();
		Thread t1 = new Thread(m);
		Thread t2 = new Thread(m);
		Thread t3 = new Thread(m);
		
		t1.start();
		t2.start();
		t3.start();

	}

}



7、Java的线程生命周期


线程经过其生命周期的各个阶段。下图显示了一个线程完整的生命周期。


新状态： 一个新产生的线程从新状态开始了它的生命周期。它保持这个状态直至程序start这个线程。

运行状态：当一个新状态的线程被start以后，线程就变成可运行状态，一个线程在此状态下被认为是开始执行其任务

就绪状态：当一个线程等待另外一个线程执行一个任务的时候，该线程就进入就绪状态。当另一个线程给就绪状态的线程发送信号时，该线程才重新切换到运行状态。

休眠状态：由于一个线程的时间片用完了，该线程从运行状态进入休眠状态。当时间间隔到期或者等待的时间发生了，该状态的线程切换到运行状态。

终止状态：一个运行状态的线程完成任务或者其他终止条件发生，该线程就切换到终止状态。

 

Vincent8080
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值