本文详细解释JAVA多线程编程,首先对进程和线程做了区别,其次介绍线程的两种实现方式,即继承Thread类和实现Runnable接口,然后讨论了线程常用的方法和优先级,最后介绍了线程的同步和死锁以及线程的生命周期。
进程:是应用程序的运行实例,是应用程序的一次动态执行。进程是由进程控制块、程序段和数据段3部分组成的。进程是操作系统进行资源分配的单位。
线程:是进程中的一个实体,其本身依靠程序进行运行,是程序中的顺序控制流,只能使用分配给程序的资源和环境。线程是被系统独立调度和分派的基本单位。
单线程:程序中只存在一个线程,即主线程。
多线程:在一个程序中运行多个任务,其目的是为了更好地使用CPU资源。
进程与线程的区别:
(1)、一个程序至少拥有一个进程,一个进程至少有一个线程;
(2)、进程在执行过程中拥有独立的内存单元,而多个线程共享进程所拥有的内存;
(3)、进程可以独立运行,但是线程不可以独立运行,必须依存在进程中,由使用该进程的应用程序提供多个线程执行控制。
Java中线程的实现类是Thread类,该类位于java.lang包中。Thread类不可直接实例化,必须通过派生Thread类的子类来操作线程。
JAVA线程的实现共两种方式,即:
——继承Thread类
——实现Runnable接口
我们知道Thread类不可直接实例化,必须通过派生Thread类的子类来操作线程,因此这两种方法都必须通过派生子类并重写run()方法来实现线程。
首先通过继承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();
}
}
首先通过实现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();
}
}
线程共包括5个主要的状态,即:
——创建状态:准备好了一个多线程的对象
——就绪状态:调用了start()方法,等待CPU进行调度
——运行状态:执行run()方法
——阻塞状态:暂时停止执行,可能将资源交给其他线程使用
——终止状态:即死亡状态,也就是线程销毁。
线程的常用方法基本上都在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);
// }
}
}
线程的优先级分为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();
}
}
为了防止资源的访问冲突,Java提供了进程的同步机制,通过同步和死锁可以有效控制进程的资源分配问题。
在代码块上加上“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();
}
}
除了代码块可以同步,方法也是可以同步的。
方法同步格式为:
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();
}
}
线程经过其生命周期的各个阶段。下图显示了一个线程完整的生命周期。
新状态: 一个新产生的线程从新状态开始了它的生命周期。它保持这个状态直至程序start这个线程。
运行状态:当一个新状态的线程被start以后,线程就变成可运行状态,一个线程在此状态下被认为是开始执行其任务
就绪状态:当一个线程等待另外一个线程执行一个任务的时候,该线程就进入就绪状态。当另一个线程给就绪状态的线程发送信号时,该线程才重新切换到运行状态。
休眠状态:由于一个线程的时间片用完了,该线程从运行状态进入休眠状态。当时间间隔到期或者等待的时间发生了,该状态的线程切换到运行状态。
终止状态:一个运行状态的线程完成任务或者其他终止条件发生,该线程就切换到终止状态。