结合简单demo分析线程及多线程的使用

最新推荐文章于 2025-09-13 09:06:35 发布

转载最新推荐文章于 2025-09-13 09:06:35 发布 · 78 阅读

1 ·

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/java1314/blog/1162716

文章标签：

#java #操作系统 #python

本文深入讲解Java中的线程概念，包括线程的创建与实现方式、生命周期及其状态转换等内容。并通过银行取现和资源调用两个案例，演示如何解决多线程访问同一资源时可能出现的冲突问题。

2019独角兽企业重金招聘Python工程师标准>>>

Java中线程（Thread）的知识很重要，没有它，我们项目中的很多功能都无法实现。跟线程有关的是进程，日常生活中我们听的比较多的是进程，通常我们的电脑卡了，我们就会说要杀进程。进程跟线程是不同的概念，两者有区别也有联系。进程，通俗的讲就是我们电脑中运行中的程序，程序的概念是静态的，进程是动态的概念。像我们电脑运行的视频播放器，音乐播放器都是进程。线程，是运行在进程中的顺序控制流，只能使用分配给进程的资源和环境。一个进程中至少会有一个线程。

　　了解线程的相关概念后，我们现在来将如何实现线程。线程的实现方式有两种。一种是通过继承Thread类，并重写run()方法实现；另一种是通过实现Runnable接口并实现其run()方法。下面通过例子来分析两种实现的区别。

创建线程类

1、通过继承Thread类

package thread;
/**
 * 
 * @author CIACs
 *线程的生成通过继承Thread类实现
 */
public class ThreadTest {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1();
        t1.start();
        MyThread2 t2 = new MyThread2();
        t2.start();
    }

}

class MyThread1  extends Thread
{
    
    @Override
    public void run() {
        for(int i=0;i<50;i++)
        {
            System.out.println("MyThread1 running: "+i);
        }
    }
}
class MyThread2 extends Thread
{
    @Override
    public void run() {
        for(int i=0;i<50;i++)
        {
            System.out.println("MyThread2 running： "+i);
        }
    }
}

控制台输出结果：

在这里我们可以看到两个线程会交叉执行，并不是一个先执行完后，另一个再执行。这就是说当线程启动后我们是不能控制执行顺序的。（当然是在还没用synchronized、wait()、notify()的时候）

2、通过实现Runnable接口

package thread;
/**
 * 
 * @author CIACs
 *线程通过实现Runnable接口生成
 */
public class ThreadTest2 {
    public static void main(String[] args) {
        Thread1 t1 = new Thread1();
        new Thread(t1).start();
        Thread2 t2 = new Thread2();
        new Thread(t2).start();
    }

}

class Thread1 implements Runnable
{
    @Override
    public void run() {
        for(int i=0;i<50;i++)
        {
            System.out.println("Thread1 running "+i);
        }
        
    }
}

class Thread2 implements Runnable
{
    @Override
    public void run() {
        for(int i=0;i<50;i++)
        {
            System.out.println("Thread2 running "+i);
        }
        
    }
}

控制台输出结果：

在这里我只上传了部分结果的截图，我们所要的在这部分截图中就可以看出了。

　　在编写程序时我们把希望线程执行的代码放到run()方法中，然后通过调用start()方法来启动线程，start()方法会为线程的执行准备好资源，之后再去调用run()方法，当某个类继承了Thread类后，该类就是线程类。线程的消亡不能通过调用stop()方法，而是让run()方法自然结束。

　　每个线程有其优先级，最高为10(MAX_PRIORITY)，最低为1(MIN_PRIORITY)，设置优先级是为了在多线程环境中便于系统对线程的调度，同等情况下，优先级高的会先比优先级低的执行。当然操作系统也不是完全按照优先级高低执行的，否则有可能优先级低的会一直处于等待状态，操作系统有自己的调度算法（这里就先不展开讨论了）。当运行中的线程调用了yield()方法，就会让出cpu的占用；调用sleep()方法会使线程进入睡眠状态，此时其他线程也就可以占用cpu资源了；有另一个更高优先级的线程出现也会导致运行中的线程让出cpu资源。有些调度算法是分配固定的时间片给线程执行，在这段时间内可以占用cpu，一旦用完就必须让出cpu资源。

在java中没有任何机制可以保证线程的执行顺序,两种做法只不过是增加了线程之间切换的几率而已.

线程的生命周期有如下四个

1、创建状态，当用new创建一个新的线程对象时，该线程处于创建状态，但此时系统没有分配资源给它。

2、可运行状态，执行线程的start()方法后系统将会分配线程运行所需的系统资源，并调用线程体run()方法，此时线程处于可运行状态。

3、不可运行状态，当线程调用了sleep()方法，或者wait()方法时，线程处于不可运行状态，线程的输入输出阻塞时也会导致线程不可运行。

4、消亡状态，当线程的run()方法执行结束后，就进入消亡状态。

下图是普通线程的状态转换图：

当使用了synchronized关键字时，线程的状态转换图会有点不同，如下图

控制多线程同步，使用wait()和notify()的线程状态转换图如下：

　　对于单核cpu来说，某一时刻只能有一个线程在执行，但在宏观上我们会看到多个进程在执行，这就是微观串行，宏观上并行。现在单核的电脑基本上已经没有了。多核的电脑就可以实现微观并行。多线程编程就是为了最大限度的利用cpu资源。例如当某一个线程和外设打交道时，此时它不需要用到cpu资源，但它仍然占着cpu，其他的线程就不能利用，多线程编程就可以解决该问题。多线程是多任务处理的一种特殊形式。但是多线程可能会造成冲突，两个或多个线程要同时访问一个共同资源。

案例

1.银行取现

账户(银行)类:

其中包含扣款操作getMoney()

package com.top.thread.banktest;

public class BankAccount {
	private int MyMoney = 1000;
	public void  getMoney(int money){
		System.out.println("输入取款金额: "+ money+";");
		if(MyMoney <=0 || (MyMoney-money)<0 ){
			System.out.println("余额不足");
		}else{
			try {
				//当一个线程进入到取钱代码部分时先进行了睡眠，
				// 另一个也进来了，且也进入睡眠。当其中一个醒来时，取完钱后，另一个也醒来继续取钱。
				// 结果: 1000 - 700 = 300, 1000 - 400 = 600; 存在异常,实际结果应该是: 1000-700-400;禁止提取: 余额不足
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
			MyMoney = MyMoney-money;
		}
		
		 System.out.println("账户剩余的钱"+MyMoney);
	}
}

线程(取现操作)类:

调用扣款,及设置取现金额

package com.top.thread.banktest;

public class ThreadBanck extends Thread{
	private BankAccount MyBank;
	private int subMoeny; 
	public ThreadBanck(BankAccount ba){
		MyBank = ba;
	}
	public void run(){
		synchronized(MyBank){
			MyBank.getMoney(subMoeny);
		}
	}
	public final int getSubMoeny() {
		return subMoeny;
	}
	public final void setSubMoeny(int subMoeny) {
		this.subMoeny = subMoeny;
	}
	
}

测试类:

package com.top.thread.banktest;
/**
 * <p class="detail">
 * 功能： 以银行取款为例，有一个账号，里面存1000元，
 * 			然后创建两个线程模拟从银行柜台和ATM同时个取N元。这里我们的银行卡不能透支。
 * 
 * 解决方法: synchronized关键字是同步的意思，当synchronized修饰一个方法时，该方法叫做同步方法。
 * 	我们这里 同步getMoney()方法,同步ThreadBanck.MyBank 这个对象也行, 同步后, 只许一个线程访问该对象,不能同时访问;
 * </p>
 * @ClassName: BankThreadTest 
 * @version V1.0  
 * @date 2017-7-5  
 */
public class BankThreadTest {
	 public static void main(String[] args) {
		BankAccount myBank = new BankAccount();
		
			ThreadBanck t1 = new ThreadBanck(myBank);
			t1.setSubMoeny(700);
			ThreadBanck t2 = new ThreadBanck(myBank);
			t2.setSubMoeny(400);
			
			t1.start();
			t2.start();
		
	 }
}

测试代码若注释掉synchronized关键字修饰

控制台输出结果：

synchronized关键字是同步的意思，当synchronized修饰一个方法时，该方法叫做同步方法。Java中的每个对象都有一个锁(lock)或者叫监视器(monitor)，当我们使用synchronized关键字修饰一个对象的方法时，就会把这个对象上锁，当该对象上锁时，其他的线程就无法再访问该对象的方法，直到线程结束或抛出异常，该对象的锁就会释放掉。看似在方法前加上synchronized关键字修饰好像完美的解决了多线程访问同一资源的冲突问题，但是由于synchronized是粗粒度的，也就是使用了该关键字会把方法所对应的类也会锁上，该类的任何其他方法都不会被其他线程所访问，这样就导致了资源利用率降低。为了解决这个方法，我们还是要利用synchronized关键字。此时synchronized关键字锁的是我们创建的任何一个对象。synchronized块代码如下

private obj = new Object();
synchronized(obj)
{
     //线程要执行的代码
}

此时我们锁的是我们创建的一个任一对象，synchronized块外面的方法是没有被锁的，也就是说其他线程可以访问synchronized块外面的方法。

2.资源调用(流水线工厂调用)

wait()跟notify()方法可以实现线程的等待和唤醒操作，这两个方法都是定义在Object类中的，而且是final的，因此会被所有的java类所继承，且无法重写。调用这两个方法要求线程已经获得了对象的锁，因此会把这两个方法放在synchronized方法或块中，且是成对出现的。执行wait()时，线程会释放对象的锁，还有一个方法也会使线程暂停执行，那就是sleep()方法，不过该方法不会释放对象的锁。

　　生产者，消费者问题在每一本学习线程的书上都会有提到，大概就是说生产者生产了商品就通知消费者消费商品，当消费者消费了商品酒通知生产者生产商品，这里涉及到了线程间的通信。我们用输出0和1来模拟生产者消费者问题。当number为1时就要减一，当number为0时就要加一。要解决该问题就要用wait()跟notify()方法结合synchronized的使用。

1.Number 类

package com.top.thread.numbertest;

public class Number {
	private int number = 1;
	static int maxGoods = 100;
	static int minGoods = 10;
	public synchronized void AddNumber(){
		if(number > maxGoods){
			try{
				//当条件不符合进入等待,让出cpu资源
				System.out.println("产品已满,请稍候再生产");
				wait();
			} catch (InterruptedException exception){
				exception.printStackTrace();
			}
		}

		// 执行加操作
		number+=50;
		System.out.println("库存加: "+ number);
		// 唤醒减操作
		notify();
		
	}
	
	
	public synchronized void SubNumber(){
		if(number < minGoods ){
			// 等于0时,进入等待状态
			try {
				System.out.println("缺货,稍候再取");
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		
		//执行减减操作
		number-=30;
		System.out.println("库存减: "+number);
		//唤醒加操作
		notify();
	}
	
}

2.AddThread

package com.top.thread.numbertest;

public class AddThread extends Thread {
	
	//设置执行的标志
	boolean flag = true;
	private Number number;
	public AddThread(Number nm){
		this.number = nm;
	}
	// 改变标志,使线程停止
	public void setFlag(){
		this.flag =false;
	}
	
	
	public void run(){
		while(flag){
			try {
				Thread.sleep((long)(Math.random()*1000));
				this.number.AddNumber();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

3.SubThread

package com.top.thread.numbertest;

public class SubThread extends Thread {
	//设置执行的标志
		boolean flag = true;
		private Number number;
		public SubThread(Number nm){
			this.number = nm;
		}
		// 改变标志,使线程停止
		public void setFlag(){
			this.flag =false;
		}
		
		
		public void run(){
			while(flag){
				try {
					Thread.sleep((long)(Math.random()*1000));
					this.number.SubNumber();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
}

客户端

package com.top.thread.numbertest;

public class Test {
	public static void main(String[] args) {
		Number num = new Number();
		AddThread add =new AddThread(num);
		SubThread sub =new SubThread(num);
		add.start();
		sub.start();
		
		try {
			Thread.sleep(2000l);
			// 停止取货
			sub.setFlag();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		if(sub.isAlive()){
			System.out.println("停止取货");
		}
		
	}
}

陷入死循环等待中....

在这个例子中我利用flag标志来控制线程的停止和执行，我们不会用stop()方法去控制线程的停止。

　　在线程的使用中我们还要注意的是如果线程中有控制的是局部变量则每个线程对局部变量的改变互不影响，如果是成员变量则会影响到其他线程。使用好线程，我们能提高做事的效率。

转载于:https://my.oschina.net/java1314/blog/1162716