Java 多线程
半身风雪 人气:0一、Java 中的线程
一个Java 程序从main() 方法开始执行,然后按照既定的代码逻辑执行,看似没有其他线程参与,但实际上Java
程序天生就是多线程程序,因为执行main() 方法的是一个名称为main 的线程。
public static void main(String[] args) { // java 虚拟机线程系统的管理接口 ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean(); // 不需要获取同步的monitor 和synchronizer 信息,仅仅获取线程和线程堆栈信息 ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false); // 遍历线程,仅打印线程ID 和线程名称信息 for (ThreadInfo threadInfo : threadInfos) { System.out.println("线程ID" + threadInfo.getThreadId() + "线程名" + threadInfo.getThreadName()); } }
上面代码输出的结果:
- $\textcolor{red}{Monitor Ctrl-Break}$ 监控 Ctrl-Break 中断信号的
- $\textcolor{red}{Signal Dispatcher}$ 分发处理发送给 JVM 信号的线程
- $\textcolor{red}{ Finalizer }$ 调用对象 finalize 方法的线程
- $\textcolor{red}{Reference Handler}$ 清除 Reference 的线程
- $\textcolor{red}{ main }$ main 线程,用户程序入口
从上面的例子中,我们能发现,在Java中短短的几行代码,就给我们启动了5个线程,当然,不同的版本,启动的线程数量也不一样,由此我们可以得出:**Java
天生就是多线程的**
1、启动
线程的启动方式有两种(源码中的注释是这么写的)参见代码:cn.enjoyedu.ch1.base.NewThread:
- X extends Thread;,然后 X.start
- X implements Runnable;然后交给 Thread 运行
示例代码:(派生自Thread 类,来实现我们的两种线程启动方式)
/** * 扩展自Thread 类 */ private static class UserThread extends Thread{ @Override public void run() { System.out.println("UserThread.run"); } } /** * 扩展自 Runnable 类 */ private static class UserRunnable implements Runnable { @Override public void run() { System.out.println("UserRunnable.run"); } } public static void main(String[] args) { UserThread userThread = new UserThread(); userThread.start(); UserRunnable userRunnable = new UserRunnable(); new Thread(userRunnable).start(); }
Thread 和 Runnable 的区别:
Thread
是Java 里对线程的唯一抽象。Runnable
是Java对任务(业务逻辑)的抽象。Thread
可以接受任意一个Runnable
的实例并执行。
2、中止
线程自然终止:
要么是run 执行完成了,要么是抛出了一个未处理的异常导致线程提前结束。stop:
暂停、恢复和停止操作对应在线程Thread的API就是suspend()、resume() 和 stop()
。但是这些API都是过期的,不再建议使用。不建议使用的主要原因有:以suspend()
方法为例,在调用后,线程不会释放已占有的资源(比如锁),而是占有资源进入睡眠状态,这样容易引发死锁问题。同样,stop()
方法在终结一个线程时,不会保证线程的资源正常释放,通常是没有给予线程完成资源释放的机会,因此会到导致程序可能工作在不确定的状态下。整因为suspend()、resume() 和 stop()
方法带来的副作用,这些方法才会被标注为不建议使用的过期方法中。中断:
安全的中止则是其它线程通过调用线程A的interrupt()
方法对其进行中止操作,中断代表着其它线程对A线程打了个招呼,“A, 你要中断了”,不代表线程A 会立即停止自己的工作,同样A线程可以不理会这种请求。因为Java 中的线程是协作式的,不是抢占式。线程通过检查自身的中断标志位是否被置为true来进行响应。
private static class UserThread extends Thread{ public UserThread(String name){ super(name); } @Override public void run() { String threadName = Thread.currentThread().getName(); System.out.println(threadName + "interrupt flag = " + isInterrupted()); while (!isInterrupted()){ // while (!Thread.interrupted()){ // while (true){ System.out.println(threadName+ "is running"); System.out.println(threadName+ "inner interrupt flag = "+ isInterrupted()); } System.out.println(threadName+ "interrupt flag = " + isInterrupted()); } } public static void main(String[] args) { Thread endTread = new UserThread("endTread"); endTread.start(); try { Thread.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); } // 中断线程, 其实设置线程的标识位 endTread.interrupt(); }
运行上面的代码:
我们发现,在使用isInterrupted()
进行线程中断的之后,isInterrupted()
会返回一个true。
我们一起来看一下isInterrupted() 方法的源码:
我们再使用一下静态的 interrupted()
方法,他返回的也是一个bool 值,
先看一下这个方法的源码:
从源码中我们发现,它返回也是中断标识符,但是,它把中断标识符给重新赋值成了true。
我们来看一下运行效果:
由此我们可以总结出:**线程通过方法 isInterrupted()
来进行判断是否被中断,也可以调用静态方法 Thread.interrupted()
来进行判断当前线程是否被中断,不过 Thread.interrupted()
会同时将中断标识位改写为 false
。**
3、阻塞
如果一个线程处于阻塞状态(如线程调用了 thread.sleep、thread.join、 thread.wait 等)
,则线程在检查中断标识时,如果发现中断标识位true
,则会在这些阻塞方法调用处抛出InterruptedException
异常,并且在抛出异常后会立即将线程的中断标识位清除,即重新设置为true
。
private static class UserThread extends Thread{ public UserThread(String name){ super(name); } @Override public void run() { String threadName = Thread.currentThread().getName(); System.out.println(threadName + "interrupt flag = " + isInterrupted()); while (!isInterrupted()){ try { Thread.sleep(100); } catch (InterruptedException e) { System.out.println(threadName+ "inner interrupt flag = "+ isInterrupted()); e.printStackTrace(); } System.out.println(threadName+ "is running"); } System.out.println(threadName+ "interrupt flag = " + isInterrupted()); } } public static void main(String[] args) { Thread endTread = new UserThread("endTread"); endTread.start(); try { Thread.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); } // 中断线程, 其实设置线程的标识位 endTread.interrupt(); }
上面代码运行结果:
那么像这种,我们该怎么去中中断操作呢?只需要在??catch?
? 中调用??interrupt()?
? 方法就可以了
代码运行结果:
4、深入理解run 和 start
- Thread类是Java里对线程概念的抽象,可以这样理解:我们通过?
?new Thread()?
? 其实只是new出一个thread的实例,还没有和操作系统中真正的线程挂起勾来。只有执行了??start()?
? 方法后,才实现了真正意义上的启动线程。 - ?
?start()?
? 方法让一个线程进入就绪队列等待分配CPU,分到CPU后才调用??run()?
?方法,??start()?
? 方法不能重复调用,如果重复调用,就会抛出异常。 - run() 方法是业务逻辑实现的地方,本质上和任意一个类的任意一个成员方法并没有任何区别,可以重复执行,也可以单独调用。
那么start() 和 run() 有什么区别呢?请看代码:
private static class UserThread extends Thread{ @Override public void run() { int i = 90; while (i > 0){ try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("I am "+Thread.currentThread().getName()+"and now the i="+ i--); } } } public static void main(String[] args) { Thread endTread = new UserThread(); endTread.setName("threadRun"); endTread.start(); }
代码运行结果:(观察运行结果,我们可以得出,调用start() 方法的时候,执行start() 方法的是子线程)
我们修改一下代码,调用??run()?
? 方法
public static void main(String[] args) { Thread endTread = new UserThread(); endTread.setName("threadRun"); endTread.run(); }
查看运行结果:(观察运行结果,我们可以得出,调用run() 方法的时候,执行run() 方法的是主线程)
5、join 方法
join() 方法是把指定的线程加入到当前线程,可以将两个交替执行的线程合并为顺序执行。
static class Students implements Runnable { private Thread thread; public Students(Thread thread) { this.thread = thread; } public Students() { } @Override public void run() { System.out.println("学生开始排队打饭。。。。。"); try { if (thread != null) thread.join(); // 休眠2 秒 Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("学生打饭完成"); } } static class Teacher implements Runnable { @Override public void run() { try { // 休眠2 秒 Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("老师开始打饭、、、、、"); System.out.println(Thread.currentThread().getName() + "老师打饭完成。"); } } public static void main(String[] args) throws InterruptedException { Teacher teacher = new Teacher(); Thread teaThread = new Thread(teacher); Students students = new Students(teaThread); Thread stuThread = new Thread(students); stuThread.start(); teaThread.start(); System.out.println("我开始打饭、、、、、"); stuThread.join(); // 让主线程休眠2 秒 Thread.sleep(2000); System.out.println(Thread.currentThread().getName()+"我打饭完成"); }
代码运行结果如下:
由上代码运行结果,我们可以得出:**在线程B中调用了线程A的??join()?
? 方法,只到线程A 执行完毕后,才会继续执行线程B的。**
6、线程优先级
在 Java 线程中,通过一个整型成员变量 priority 来控制优先级,优先级的范 围从 1~10,在线程构建的时候可以通过??setPriority(int)?
?方法来修改优先级,默认 优先级是 5,优先级高的线程分配时间片的数量要多于优先级低的线程。
设置线程优先级时,针对频繁阻塞(休眠或者I/O操作)的线程需要设置较 高优先级,而偏重计算(需要较多CPU时间或者偏运算)的线程则设置较低的 优先级,确保处理器不会被独占。在不同的 JVM 以及操作系统上,线程规划会 存在差异,有些操作系统甚至会忽略对线程优先级的设定。
7、守护线程
Daemon(守护)线程是一种支持型线程,因为它主要被用作程序中后台调 度以及支持性工作。这意味着,当一个 Java 虚拟机中不存在非 Daemon 线程的 时候,Java 虚拟机将会退出。可以通过调用??Thread.setDaemon(true)?
?将线程设置 为Daemon线程。我们一般用不上,比如垃圾回收线程就是Daemon线程。
Daemon线程被用作完成支持性工作,但是在 Java 虚拟机退出时Daemon线 程中的??finally?
? 块并不一定会执行。在构建Daemon线程时,不能依靠??finally?
? 块中 的内容来确保执行关闭或清理资源的逻辑。
8、synchronized 内置锁
线程开始运行,拥有自己的栈空间,就如同一个脚本一样,按照既定的代码 一步一步地执行,直到终止。但是,每个运行中的线程,如果仅仅是孤立地运行, 那么没有一点儿价值,或者说价值很少,如果多个线程能够相互配合完成工作, 包括数据之间的共享,协同处理事情。这将会带来巨大的价值。
Java支持多个线程同时访问一个对象或者对象的成员变量,关键字synchronized可以修饰方法或者以同步块的形式来进行使用,它主要确保多个线 程在同一个时刻,只能有一个线程处于方法或者同步块中,它保证了线程对变量 访问的可见性和排他性,又称为内置锁机制。
下面我们看一段代码,在main 方法中启动两个线程,每个线程的count 值都是10000,两个线程的和应该就是20000。
public class OnlyMain { private long count = 0; private Object object = new Object(); public long getCount() { return count; } public void incCount() { count++; } // 线程 private static class Count extends Thread { private OnlyMain onlyMain; public Count(OnlyMain onlyMain) { this.onlyMain = onlyMain; } @Override public void run() { for (int i = 0; i < 10000; i++) { // count = count++ = 10000 onlyMain.incCount(); } } } public static void main(String[] args) throws InterruptedException { OnlyMain onlyMain = new OnlyMain(); // 启动两个线程 Count count1 = new Count(onlyMain); Count count2 = new Count(onlyMain); count1.start(); count2.start(); Thread.sleep(50); System.out.println(onlyMain.count); } }
代码的运行结果是:
经过多次运行,每次运行的结果都不一样,只有在很少很少的几率的情况下,才会出现正确的20000结果值,这是为什么呢?
这是因为,两个线程同时对count 成员变量进行访问,才导致输出结果的错误。怎么解决呢?使用synchronized 内置锁。
修改上面代码中的incCount() 方法,添加一个内锁:
public synchronized void incCount() { count++; }
这样我们就能保证每次运行的正确结果了:
9、对象锁和类锁
对象锁是用于对象实例方法的锁,或者一个对象实例上,类锁 是用于类的静态方法或一个类的class 上的,我们知道,类的对象实例可以有很多个,但是每个类只有一个class对象,所有不同对象实例的对象锁是互不干扰的,但是每个类只有一个类锁。
但是有一点必须要注意的是,其实类锁只是一个概念上的东西,并不是真实存在的,类锁其实锁的是每个类的对应的class 对象。类锁和对象锁之间也是互不干扰的。
二、总结
加载全部内容