Java多线程

最新推荐文章于 2020-02-26 15:19:08 发布

pan_junbiao

最新推荐文章于 2020-02-26 15:19:08 发布

阅读量420

点赞数

分类专栏： Java 我の原创文章标签： Java 多线程

本文链接：https://blog.csdn.net/pan_junbiao/article/details/85281590

版权

我の原创同时被 2 个专栏收录

456 篇文章 21 订阅

订阅专栏

Java

67 篇文章 15 订阅

订阅专栏

如果一次只完成一件事情，会很容易实现，但现实生活中很多事情都是同时进行的，所以在Java中为了模拟这种状态，引入了线程机制。简单地说，当程序同时完成多件事情时，就是所谓的多线程。多线程应用相当广泛，使用多线程可以创建窗口程序、网络程序等。

1、线程简介

世间万物会同时完成很多工作，例如人体同时进行呼吸、血液循环、思考问题等活动，用户既可以使用计算机听歌，也可以使用它打印文件，而这些活动完全可以同时进行，这种思想放在Java中被称为并发，而将并发完成的每一件事情称为线程。

在Java中，并发机制非常重要，但是并不是所有的程序语言都支持线程。在以往的程序中，多以一个任务完成后再进行下一个项目的模式进行开发，这样下一个任务的开始必须等待前一个任务的结束。Java语言提供并发机制，程序员可以在程序中执行多个线程，每一个线程完成一个功能，并与其他线程并发执行，这种机制被称为多线程。

一个线程则是进程中的执行流程，一个进程中可以同时包括多个线程，每个线程也可以得到一小段程序的执行时间，这样一个进程就可以具有多个并发执行的线程。在单线程中，程序代码按调用顺序依次往下执行，如果需要一个进程同时完成多段代码的操作，就需要产生多线程。

2、实现线程的两种方式

在Java中主要提供两种方式实现线程，分别为继承java.lang.Thread类与实现java.lang.Runnable接口。

2.1 继承Thread类

Thread类是java.lang包中的一个类，从这个类中实例化的对象代表线程，程序员启动一个新线程需要建立Thread实例。Thread类中常用的两个构造方法如下：

public Thread()：创建一个新的线程对象。

public Thread(String threadName)：创建一个名称为threadName的线程对象。

其它构造方法：

public Thread(Runnable target)；

public Thread(Runnable target, String name)；

public Thread(ThreadGroup group, String name) ；

public Thread(ThreadGroup group, Runnable target) ；

public Thread(ThreadGroup group, Runnable target, String name) ；

继承Thread类创建一个新的线程的语法如下：

public class ThreadTest extends Thread{
}

完成线程真正功能的代码放在类的run()方法中，当一个类继承Thread类后，就可以在该类中覆盖run()方法，将实现该线程功能的代码写入到run()方法中，然后同时调用Thread类中的start()方法执行线程，也就是调用run()方法。

示例：在项目中创建ThreadTest类，该类继承Thread类方法创建线程。

/**
 * 指定类继承Thread类
 * 
 * @author pan_junbiao
 *
 */
public class ThreadTest extends Thread
{
	private int count = 10;

	// 重写run()方法
	public void run()
	{
		while (true)
		{
			System.out.print(count + " ");
			if (--count == 0)
			{
				return;
			}
		}
	}

	public static void main(String[] args)
	{
		ThreadTest threadTest = new ThreadTest();
		threadTest.start();
	}
}

执行结果：

2.2 实现Runnable接口

到目前为止，线程都是通过扩展Thread类来创建的，如果程序员需要继承其他类（非Thread类）并使该程序可以使用线程，就需要使用Runnable接口。例如，一个扩展JFrame类的GUI程序不可能再继承Thread类，因为Java语言中不支持多继承，这时该类就需要实现Runnable接口使其具有使用线程的功能。

实现Runnable接口的语法如下：

public class Thread extends Object implements Runnable

说明：查看API可以发现，实质上Thread类实现了Runnable接口，其中的run()方法正是对Runnable接口中的run()方法的具体实现。

实现Runnable接口的程序会创建一个Thread对象，并将Runable对象与Thread对象相关联，Thread类中有以下两个构造方法：

public Thread(Runnable target)；

public Thread(Runnable target, String name)；

这两个构造方法的参数都存在Runnable实例，使用以上构造方法就可以将Runnable实例与Thread实例相关联。

使用Runnable接口启动新的线程步骤如下：

（1）创建Runnable对象。

（2）使用参数为Runnable对象的构造方法创建Thread实例。

（3）调用start()方法启动线程。

示例：使用Runnable接口实现多线程。

/**
 * 使用Runnable接口实现多线程
 * 
 * @author pan_junbiao
 *
 */
public class RunnableTest
{

	public static void main(String[] args)
	{
		// 1、创建Runnable接口对象，并实现run()方法
		Runnable myRunnable = new Runnable() {
			private int count = 10;

			public void run()
			{
				try
				{
					while (true)
					{
						System.out.print(count + " ");
						Thread.sleep(500);
						if (--count == 0)
						{
							return;
						}
					}
				} catch (InterruptedException e)
				{
					e.printStackTrace();
				}
			}
		};

		// 2、使用参数为Runnable对象的构造方法创建Thread实例
		Thread myThread = new Thread(myRunnable);

		// 3、调用start()方法启动线程
		myThread.start();
	}
}

3、线程的生命周期

线程具有生命周期，其中包含7种状态，分别为出生状态、就绪状态、运行状态、等待状态、休眠状态、阻塞状态和死亡状态。出生状态就是用户在创建线程时处于的状态，在用户使用该线程实例调用start()方法之前线程都处于出生状态；当用户调用start()方法后，线程处于就绪状态（又被称为可执行状态）；当线程得到系统资源后就进入运行状态。

一旦线程进入可执行状态，它会在就绪与运行状态下转换，同时也有可能进入等待、休眠、阻塞或死亡状态。当处于运行状态下的线程调用Thread类中的wait()方法时，该线程便进入等待状态，进入等待状态的线程必须调用Thread类中的notify()方法才能被唤醒，而notifyAll()方法是将所有处于等待状态下的线程唤醒；当线程调用Thread类中的sleep()方法时，则会进入休眠状态。如果一个线程咋运行状态下发出输入/输出请求，该线程将进入阻塞状态，在其等待输入/输出结束时线程进入就绪状态，对应阻塞的线程来说，即使系统资源空闲，线程依然不能回到运行状态。当线程的run()方法执行完毕时，线程进入死亡状态。

线程处于就绪状态有以下几种方法：

（1）调用sleep()方法。

（2）调用wait()方法。

（3）等待输入/输出完成。

当线程处于就绪状态后，可以用以下几种方法使线程再次进入运行状态。

（1）线程调用notify()方法。

（2）线程调用notifyAll()方法。

（3）线程调用interrupt()方法。

（4）线程的休眠时间结束。

（5）输入/输出结束。

4、操作线程的方法

操作线程有很多方法，这些方法可以使线程从某一种状态过渡到另一种状态。

Thread类的常用方法：

方法	说明
sleep(long millis)	使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性。
sleep(long millis, int nanos)	导致正在执行的线程以指定的毫秒数加上指定的纳秒数来暂停（临时停止执行），这取决于系统定时器和调度器的精度和准确性。
wait()	该方法继承至Object类，导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法。
wait(long timeout)	该方法继承至Object类，导致当前线程等待，直到另一个线程调用 notify()方法或该对象的 notifyAll()方法，或者指定的时间已过。
wait(long timeout, int nanos)	该方法继承至Object类，导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法，或者某些其他线程中断当前线程，或一定量的实时时间。
notify()	该方法继承至Object类，唤醒正在等待对象监视器的单个线程。
notifyAll()	该方法继承至Object类，唤醒正在等待对象监视器的所有线程。
interrupt()	中断这个线程。
currentThread()	返回对当前正在执行的线程对象的引用。
getId()	返回此线程的标识符。
getName()	返回此线程的名称。
setName(String name)	将此线程的名称更改为等于参数 name 。
getPriority()	返回此线程的优先级。
setPriority(int newPriority)	更改此线程的优先级。
getState()	返回此线程的状态。
getThreadGroup()	返回此线程所属的线程组。
holdsLock(Object obj)	返回 true当且仅当当前线程在指定的对象上保持监视器锁。
interrupted()	判断当前线程是否中断。
isAlive()	判断这个线程是否活着。
isDaemon()	判断这个线程是否是守护线程。
isInterrupted()	判断这个线程是否被中断。
join()	线程的加入。
join(long millis)	线程的加入。
join(long millis, int nanos)	线程的加入。
run()	如果这个线程使用单独的Runnable运行对象构造，则调用该Runnable对象的run方法; 否则，此方法不执行任何操作并返回。
start()	导致此线程开始执行; Java虚拟机调用此线程的run方法。
setContextClassLoader(ClassLoader cl)	设置此线程的上下文ClassLoader。
getContextClassLoader()	返回此Thread的上下文ClassLoader。
yield()	对调度程序的一个暗示，即当前线程愿意产生当前使用的处理器。

4.1 线程的休眠

sleep(long millis)方法需要一个参数用于指定该线程休眠的时间，该时间以毫秒为单位。

示例：使用Thread类的sleep()方法休眠2秒。

try
{
	Thread.sleep(2000);
} catch (InterruptedException e)
{
	e.printStackTrace();
}

4.2 线程的加入

如果当前某程序为多线程程序，假如存在一个线程A，现在需要插入线程B，并要求线程B先执行完毕，然后在继续执行线程A，此时可以使用Thread类中的join()方法来完成。这就好比此时读者正在看电视，却突然有人上门收水费，读者必须付完水费后才能继续看电视。

当某个线程使用join()方法加入到另外一个线程时，另外一个线程会等待该线程执行完毕后再继续执行。

示例：在项目中创建JoinTest类，该类继承了JFrame类。该实现包括两个进度条，进度条的进度由线程来控制，通过使用join()方法使上面的进度条必须等待下面的进度条完成后才可以继续。

import java.awt.BorderLayout;

import javax.swing.JFrame;
import javax.swing.JProgressBar;

/**
 * 线程的加入
 * 
 * @author pan_junbiao
 *
 */
public class JoinTest extends JFrame
{
	// 定义两个线程
	private Thread threadA;
	private Thread threadB;

	// 定义两个进度条组件
	final JProgressBar progressBarA = new JProgressBar();
	final JProgressBar progressBarB = new JProgressBar();

	public JoinTest()
	{
		super();
		// 将进度条A设置在窗体的最北面
		this.getContentPane().add(progressBarA, BorderLayout.NORTH);
		// 将进度条B设置在窗体的最南面
		this.getContentPane().add(progressBarB, BorderLayout.SOUTH);
		// 设置进度条显示数字字符
		progressBarA.setStringPainted(true);
		progressBarB.setStringPainted(true);
		// 使用匿名内部类形式初始化线程A
		threadA = new Thread(new Runnable() {
			int count = 0;

			// 重写run()方法
			public void run()
			{
				while (true)
				{
					// 设置进度条的当前值
					progressBarA.setValue(++count);
					try
					{
						// 使线程A休眠
						Thread.sleep(100);
						// 使线程B调用join()方法
						threadB.join();
					} catch (InterruptedException e)
					{
						e.printStackTrace();
					}
				}
			}
		});
		// 启动线程A
		threadA.start();

		// 初始化线程B
		threadB = new Thread(new Runnable() {
			int count = 0;

			// 重写run()方法
			public void run()
			{
				while (true)
				{
					progressBarB.setValue(++count);
					try
					{
						Thread.sleep(100);
					} catch (InterruptedException e)
					{
						e.printStackTrace();
					}

					// 当count变量增长为100时
					if (count == 100)
					{
						break; // 跳出循环
					}
				}
			}
		});
		// 启动线程B
		threadB.start();
	}

	// 设置窗体的各种属性的方法
	public static void init(JFrame frame, int width, int height)
	{
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setSize(width, height);
		frame.setVisible(true);
		frame.setLocationRelativeTo(null);// 窗体居中显示
	}

	// 执行方法
	public static void main(String[] args)
	{
		init(new JoinTest(), 100, 100);
	}
}

4.3 线程的中断

以往有的时候会使用stop()方法停止线程，但当前版本的JDK早已废除了stop()方法，不建议使用stop()方法来停止一个线程的运行。现在提倡出run()方法中使用无限循环的形式，然后使用一个布尔型标记控制循环的停止。

如果线程时因为使用了sleep()或wait()方法进入了就绪状态，可以使用Thread类中interrupt()方法使线程离开run()方法，同时结束线程，但程序会抛出InterruptedException异常，用户可以在该异常时完成线程的中断业务处理，如终止while循环。

示例：在项目中创建Interrupted()方法，该类实现了Runnable接口，创建一个进度条，在表示进度条的线程中使用interrupted()方法。

import java.awt.BorderLayout;
import javax.swing.JFrame;
import javax.swing.JProgressBar;

/**
 * 线程的中断
 * 
 * @author pan_junbiao
 *
 */
public class InterruptedSwing extends JFrame
{
	Thread thread;

	public InterruptedSwing()
	{
		super();

		// 创建进度条
		final JProgressBar progressBar = new JProgressBar();
		// 将进度条设置在窗体的最北面
		this.getContentPane().add(progressBar, BorderLayout.NORTH);
		// 设置进度条显示数字字符
		progressBar.setStringPainted(true);
		// 初始化线程
		thread = new Thread(new Runnable() {
			int count = 0;

			// 重写run()方法
			public void run()
			{
				while (true)
				{
					// 设置进度条当前值
					progressBar.setValue(++count);

					try
					{
						// 使线程休眠
						thread.sleep(1000);

						// 捕获InterruptedException异常
					} catch (InterruptedException e)
					{
						System.out.println("当前线程被中断");
						break;
					}
				}
			}
		});

		// 启动线程
		thread.start();

		// 中断线程
		thread.interrupt();
	}

	// 设置窗体的各种属性的方法
	public static void init(JFrame frame, int width, int height)
	{
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setSize(width, height);
		frame.setVisible(true);
		frame.setLocationRelativeTo(null);// 窗体居中显示
	}

	// 执行方法
	public static void main(String[] args)
	{
		init(new InterruptedSwing(), 100, 100);
	}
}

4.4 线程的礼让

Thread类中提供了一种礼让方法，使用yield()方法表示，它只是给当前处于运行状态的线程一个提醒，告知它可以将资源礼让给其它线程，但这仅是一种暗示，没有任何一种机制保证当前线程会将资源礼让。

yield()方法使具有同样优先级的线程有进入可执行状态的机会，当当前线程放弃执行权时会再度回到就绪状态。对于支持多任务的操作系统来说，不需要调用yield()方法，因为操作系统会为线程自动分配CPU时间片来执行。

5、线程的优先级

每个线程都具有各自的优先级，线程的优先级可以在程序中表明该线程的重要性，如果有很多线程处于就绪状态，系统会根据优先级来决定首先使哪个线程进入运行状态。但这并不意味着低优先级的线程得不到运行，而只是它运行的几率比较小，比如垃圾回收线程的优先级就较低。

Thread类中包含的成员变量代表了线程的某些优先级，比如Thread.MIN_PRIORITY（常数1）、Thread.MAX_PRIORITY（常数2）、Thread.NORM_PRIORITY（常数5）。其中每个线程的优先级都在Thread.MIN_PRIORITY~Thread.MAX_PRIORITY之间，在默认情况下其优先级都是Thread.NORM_ PRIORITY。每个新产生的线程都继承了父线程的优先级。

线程的优先级可以使用setPriority(int newPriority)方法调整，如果使用该方法设置的优先级不在1~10之内（数字越大优先级越高），将产生IllegalArgumentException异常。

示例：在项目中创建PriorityTest类，该类实现了Runnable接口。创建4个进度条，分别由4个线程来控制，并且为这4个线程设置不同的优先级。

import java.awt.GridLayout;
import javax.swing.JFrame;
import javax.swing.JProgressBar;

/**
 * 线程的优先级
 * 
 * @author pan_junbiao
 *
 */
public class PriorityTest extends JFrame
{
	private static final long serialVersionUID = 1L;
	private Thread threadA;
	private Thread threadB;
	private Thread threadC;
	private Thread threadD;

	public PriorityTest()
	{
		getContentPane().setLayout(new GridLayout(4, 1));
		// 分别实例化4个线程
		final JProgressBar progressBar = new JProgressBar();
		final JProgressBar progressBar2 = new JProgressBar();
		final JProgressBar progressBar3 = new JProgressBar();
		final JProgressBar progressBar4 = new JProgressBar();
		getContentPane().add(progressBar);
		getContentPane().add(progressBar2);
		getContentPane().add(progressBar3);
		getContentPane().add(progressBar4);
		progressBar.setStringPainted(true);
		progressBar2.setStringPainted(true);
		progressBar3.setStringPainted(true);
		progressBar4.setStringPainted(true);
		threadA = new Thread(new MyThread(progressBar));
		threadB = new Thread(new MyThread(progressBar2));
		threadC = new Thread(new MyThread(progressBar3));
		threadD = new Thread(new MyThread(progressBar4));
		setPriority("threadA", 5, threadA);
		setPriority("threadB", 5, threadB);
		setPriority("threadC", 4, threadC);
		setPriority("threadD", 3, threadD);
	}

	// 定义设置线程的名称、优先级的方法
	public static void setPriority(String threadName, int priority, Thread t)
	{
		t.setPriority(priority); // 设置线程的优先级
		t.setName(threadName); // 设置线程的名称
		t.start(); // 启动线程
	}

	public static void main(String[] args)
	{
		init(new PriorityTest(), 100, 100);
	}

	public static void init(JFrame frame, int width, int height)
	{
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setSize(width, height);
		frame.setVisible(true);
		frame.setLocationRelativeTo(null);// 窗体居中显示
	}

	private final class MyThread implements Runnable
	{ // 定义一个实现Runnable接口的类
		private final JProgressBar bar;
		int count = 0;

		private MyThread(JProgressBar bar)
		{
			this.bar = bar;
		}

		public void run()
		{ // 重写run()方法
			while (true)
			{
				bar.setValue(count += 10); // 设置滚动条的值每次自增10
				try
				{
					Thread.sleep(1000);
				} catch (InterruptedException e)
				{
					System.out.println("当前线程序被中断");
				}
			}
		}
	}
}

执行程序可以看出4个进度条好像是在一起滚动，但如果仔细观察可以看出细微差别，可以看到第一个进度条总数最先变化。由于threadA线程和threadB线程优先级最高，所以系统首先处理这两个线程，然后是threadC和threadD这两个线程。

6、线程同步

在单线程程序中，每次只能做一件事情，后面的事情需要等待前面的事情完成后才可以进行，但是如果是多线程程序，就会发生多个线程抢占资源的问题。所以在多线程编程中需要防止这些资源访问的冲突。Java提供了线程同步机制来防止资源访问的冲突。

6.1 线程安全

实际开发中，使用多线程程序的情况很多，如银行排号系统、火车站售票系统等。这种多线程的程序通常会发生问题，以火车站售票系统为例，在代码中判断当前票数是否大于0，如果大于0则执行将该票出售给乘客功能，但当两个线程同时访问这段代码时（假如这时只剩下一张票），第一个线程将票售出，与此同时第二个线程也已经执行完成判断是否有票的操作，并得出结论票数大于0，于是它也执行售出操作，这样就会产生负数。所以在编写多线程程序时，应该考虑到线程安全问题。实质上线程安全问题来源于两个线程同时存取单一对象的数据。

示例：在项目中创建ThreadSafeTest类，该类实现了Runnable接口，主要实现模拟火车站售票系统因多线程而导致错误的情形。

/**
 * 模拟火车站售票系统因多线程而导致错误的情形
 * 
 * @author pan_junbiao
 *
 */
public class ThreadSafeTest implements Runnable
{
	// 设置当前总票数
	int ticketsNum = 10;

	// 实现run()方法
	public void run()
	{
		while (true)
		{
			if (ticketsNum > 0)
			{
				try
				{
					Thread.sleep(100);
				} catch (InterruptedException e)
				{
					e.printStackTrace();
				}
				System.out.println("Tickets" + ticketsNum--);
			} else
			{
				break;
			}
		}
	}

	public static void main(String[] args)
	{
		// 实例化类对象
		ThreadSafeTest ts = new ThreadSafeTest();

		// 以该类对象分别实例化4个线程
		Thread tA = new Thread(ts);
		Thread tB = new Thread(ts);
		Thread tC = new Thread(ts);
		Thread tD = new Thread(ts);

		// 分别启动线程
		tA.start();
		tB.start();
		tC.start();
		tD.start();
	}
}

执行结果：

从执行结果中可以看出，最后打印售票剩下的票为负数，这样就出现了问题。

6.2 线程同步机制

如何解决资源共享的问题？基本上所有解决多线程资源冲突问题都会采用给定时间只允许一个线程访问共享资源，这时就需要给共享资源上一道锁。

6.2.1 同步块

在Java中提供了同步机制，可以有效地防止资源冲突。同步机制使用synchronized关键字。其语法格式：

synchronized (Object){
}

通常将共享资源的操作放置在synchronized定义的区域内，这样当其他线程也获取到这个锁时，必须等待锁被释放时才能进入该区域。Object为任意一个对象，每个对象都存在一个标志位，并具有两个值，分别为0和1。一个线程运行到同步块时首先检查该对象的标志位，如果为0状态，表明此同步块中存在其他线程在运行。这是该线程处于就绪状态，直到处于同步块中的线程执行完同步块中的代码为止。这时这是该对象的标志位被设置为1该线程才能执行同步块中的代码，并将Object对象的标志位设置为0，防止其他线程执行同步块中的代码。

示例：修改上述示例，使用synchronized同步块处理并发问题。

/**
 * 模拟火车站售票系统，使用synchronized同步块处理并发问题
 * 
 * @author pan_junbiao
 *
 */
public class ThreadSafeTest implements Runnable
{
	// 设置当前总票数
	int ticketsNum = 10;

	// 同步锁
	Object synObj = new Object();

	// 实现run()方法
	public void run()
	{
		while (true)
		{
			// 同步块
			synchronized (synObj)
			{
				if (ticketsNum > 0)
				{
					try
					{
						Thread.sleep(100);
					} catch (InterruptedException e)
					{
						e.printStackTrace();
					}
					System.out.println("Tickets" + ticketsNum--);
				} else
				{
					break;
				}
			}
		}
	}

	public static void main(String[] args)
	{
		// 实例化类对象
		ThreadSafeTest ts = new ThreadSafeTest();

		// 以该类对象分别实例化4个线程
		Thread tA = new Thread(ts);
		Thread tB = new Thread(ts);
		Thread tC = new Thread(ts);
		Thread tD = new Thread(ts);

		// 分别启动线程
		tA.start();
		tB.start();
		tC.start();
		tD.start();
	}
}

执行结果：

6.2.2 同步方法

同步方法就是在方法前面修饰synchronized关键字的方法，其语法如下：

synchronized void methodName() {
}

当某个对象调用了同步方法时，该对象上的其他同步方法必须等待该同步方法执行完毕后才能被执行。必须将每个能访问共享资源的方法修饰为synchronized，否则就会出错。

示例：在项目中创建一个类文件，在该类中定义同步方法。

/**
 * 模拟火车站售票系统，使用同步方法处理并发问题
 * 
 * @author pan_junbiao
 *
 */
public class SyncMethodTest implements Runnable
{

	// 设置当前总票数
	int ticketsNum = 10;

	// 定义同步方法
	public synchronized boolean doit()
	{
		boolean result; // 执行结果
		if (ticketsNum > 0)
		{
			try
			{
				Thread.sleep(100);
			} catch (InterruptedException e)
			{
				e.printStackTrace();
			}
			System.out.println("Tickets" + ticketsNum--);
			result = true;
		} else
		{
			result = false;
		}
		return result;
	}

	// 实现run()方法
	public void run()
	{
		boolean hasExecute; // 是否继续执行
		do
		{
			hasExecute = doit();
		} while (hasExecute);
	}

	public static void main(String[] args)
	{
		// 实例化类对象
		SyncMethodTest ts = new SyncMethodTest();

		// 以该类对象分别实例化4个线程
		Thread tA = new Thread(ts);
		Thread tB = new Thread(ts);
		Thread tC = new Thread(ts);
		Thread tD = new Thread(ts);

		// 分别启动线程
		tA.start();
		tB.start();
		tC.start();
		tD.start();
	}
}

pan_junbiao

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java多线程

如果一次只完成一件事情，会很容易实现，但现实生活中很多事情都是同时进行的，所以在Java中为了模拟这种状态，引入了线程机制。简单地说，当程序同时完成多件事情时，就是所谓的多线程。多线程应用相当广泛，使用多线程可以创建窗口程序、网络程序等。1、线程简介世间万物会同时完成很多工作，例如人体同时进行呼吸、血液循环、思考问题等活动，用户既可以使用计算机听歌，也可以使用它打印文件，而这些活动完全可以...
复制链接

扫一扫