Java 多线程
Posted Hesier
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java 多线程相关的知识,希望对你有一定的参考价值。
在Java中,一个应用程序对应着一个JVM实例(JVM进程),一般来说名字默认为java.exe或者javaw.exe(windows下可以通过任务管理器查看)。Java采用的是单线程编程模型,即在我们自己的程序中如果没有主动创建线程的话,只会创建一个线程,通常称为主线程。但是,虽然只有一个线程来执行任务,不代表JVM中只有一个线程,JVM实例在创建的时候,同时会创建很多其他的线程(比如垃圾收集器线程)。
一个进程包括多个线程,这些线程是共同享有进程占有的资源和地址空间的。进程是操作系统进行资源分配的基本单位,而线程是操作系统进行调度的基本单位。
一、线程创建
- 创建线程类(继承Thread或实现Runnable接口)
- 创建线程对象thread(如果通过实现Runnable创建线程类,则要需要将Runnable作为Thread类的参数)
- 通过start方法启动
// 继承Thread class MyThread extends Thread{ private static int num = 0; public MyThread(){ num++; } @Override public void run(){ System.out.println("主动创建的第"+num+"个线程"); } } public class Test{ public static void main(String[] args){ MyThread thread = new MyThread(); thread.start(); } } // 实现Runnable接口 class MyRunnable implements Runnable{ public MyRunnable(){} @Override public void run(){ System.out.println("子线程ID:" + Thread.currentThread().getId()); } } public class Test{ public static void main(String[] args){ MyRunnable runnable = new MyRunnable(); Thread thread = new Thread(runnable); thread.start(); } }
二、Thread 类
1、线程的状态
创建(new)、就绪(runnable)、运行(running)、阻塞(blocked)、time waiting、waiting、消亡(dead)
- 线程创建之后,不会立即进入就绪状态,因为线程的运行需要一些条件(比如内存资源:程序计数器、Java栈、本地方法栈都是线程私有的,所以需要为线程分配一定的内存空间),只有线程运行需要的所有条件满足了,才进入就绪状态。
- 当线程进入就绪状态后,不代表立刻就能获取CPU执行时间,也许此时CPU正在执行其他的事情,因此它要等待。当得到CPU执行时间之后,线程便真正进入运行状态。
- 线程在运行状态过程中,可能有多个原因导致当前线程不继续运行下去,比如用户主动让线程睡眠(睡眠一定的时间之后再重新执行)、用户主动让线程等待,或者被同步块给阻塞,此时就对应着多个状态:time waiting(睡眠或等待一定的事件)、waiting(等待被唤醒)、blocked(阻塞)。
- 当由于突然中断或者子任务执行完毕,线程就会被消亡。
线程间进行上下文切换的时候会记录程序计数器、CPU寄存器状态等数据。
2、Thread类中常用方法:
- start方法。start()用来启动一个线程,当调用start方法后,系统才会开启一个新的线程来执行用户定义的子任务,在这个过程中,会为相应的线程分配需要的资源。
- run方法。run()方法是不需要用户来调用的,当通过start方法启动一个线程之后,当线程获得了CPU执行时间,便进入run方法体去执行具体的任务。即start()内部调用了run()方法。直接调用run()方法的时候,只会是在原来的线程中调用,没有新的线程启动。
- sleep方法。sleep相当于让线程睡眠,交出CPU,让CPU去执行其他的任务。但是有,sleep方法不会释放锁,也就是说如果当前线程持有某个对象的锁,则即使调用sleep方法,其他线程也无法访问这个对象。如果调用了sleep方法,必须捕获InterruptedException异常或者将该异常向上层抛出。当线程睡眠时间满后,不一定会立即得到执行,因为此时可能CPU正在执行其他的任务。所以说调用sleep方法相当于让线程进入阻塞状态。
- yield方法。调用yield方法会让当前线程交出CPU权限,让CPU去执行其他的线程。它跟sleep方法类似,同样不会释放锁。但是yield不能控制具体的交出CPU的时间,另外,yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。注意,调用yield方法并不会让线程进入阻塞状态,而是让线程重回就绪状态,它只需要等待重新获取CPU执行时间。
- join方法。假如在main线程中,调用thread.join方法,则main方法会等待thread线程执行完毕或者等待一定的时间。如果调用的是无参join方法,则等待thread执行完毕,如果调用的是指定了时间参数的join方法,则等待一定的时间。实际上调用join方法是调用了Object的wait方法,wait方法会让线程进入阻塞状态,并且会释放线程占有的锁,并交出CPU执行权限。
- interrupt方法。调用interrupt方法可以使得处于阻塞状态的线程抛出一个异常,也就说,它可以用来中断一个正处于阻塞状态的线程。但是直接调用interrupt方法不能中断正在运行中的线程。
- 静态方法currentThread()用来获取当前线程。
- setDaemon和isDaemon 用来设置线程是否成为守护线程和判断线程是否是守护线程。守护线程和用户线程的区别在于:守护线程依赖于创建它的线程,而用户线程则不依赖。举个简单的例子:如果在main线程中创建了一个守护线程,当main方法运行完毕之后,守护线程也会随着消亡。而用户线程则不会,用户线程会一直运行直到其运行完毕。在JVM中,像垃圾收集器线程就是守护线程。
注意:wait,notify,notifyAll是属于Object。
只能在同步方法或者同步块中使用wait()方法。在执行wait()方法后,当前线程释放锁(这点与sleep和yield方法不同)。调用了wait函数的线程会一直等待,直到有其他线程调用了同一个对象的notify或者notifyAll方法才能被唤醒,需要注意的是:被唤醒并不代表立刻获得对象的锁,要等待执行notify()方法的线程执行完,即退出synchronized代码块后,当前线程才会释放锁,而呈wait状态的线程才可以获取该对象锁。
如果调用wait()方法时没有持有适当的锁,则抛出IllegalMonitorStateException,它是RuntimeException的一个子类,因此,不需要try-catch语句进行捕获异常。notify方法只会(随机)唤醒一个正在等待的线程,而notifyAll方法会唤醒所有正在等待的线程。如果一个对象之前没有调用wait方法,那么调用notify方法是没有任何影响的。
三、synchronized
1.synchronized方法
class InsertData{ private ArrayList<Integer> list = new ArrayList<>(); public void insert(Thread thread){ for(int i=0; i<5; i++){ System.out.println(thread.getName()+"insert number " + i); list.add(i); } } } public class Test{ public static void main(String[] args){ final InsertData insertData = new InsertData(); new Thread(){ public void run(){ insertData.insert(Thread.currentThread()); } }.start(); new Thread(){ public void run(){ insertData.insert(Thread.currentThread()); } }.start(); } }
输出结果为:
给insert 方法加上synchronized 关键字
class InsertData{ private ArrayList<Integer> list = new ArrayList<>(); public synchronized void insert(Thread thread){ for(int i=0; i<5; i++){ System.out.println(thread.getName()+"insert number " + i); list.add(i); } } }
输出结果为:
- 当一个线程正在访问一个对象的synchronized方法,那么其他线程不能访问该对象的其他synchronized方法。因为一个对象只有一把锁,当一个线程获取了该对象的锁之后,其他线程无法获取该对象的锁,所以无法访问该对象的其他synchronized方法。
- 当一个线程正在访问一个对象的synchronized方法,那么其他线程能访问该对象的非synchronized方法。因为访问非synchronized方法不需要获得该对象的锁,假如一个方法没用synchronized关键字修饰,说明它不会使用到临界资源,那么其他线程是可以访问这个方法的。
2.synchronized代码块
synchronized(synObject){ }
synObject可以是this,代表获取当前对象的锁,也可以是类中的一个属性,代表获取该属性的锁。
class InsertData{ private ArrayList<Integer> list = new ArrayList<>(); public void insert(Thread thread){ synchronized(this){ for(int i=0; i<5; i++){ System.out.println(thread.getName()+"insert number " + i); list.add(i); } } } }
或者:
class InsertData{ private ArrayList<Integer> list = new ArrayList<>(); private Object object = new Object(); public void insert(Thread thread){ synchronized(object){ for(int i=0; i<5; i++){ System.out.println(thread.getName()+"insert number " + i); list.add(i); } } } }
总结就是:
- 当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时,其他线程对“该对象”的该“synchronized方法”或者“synchronized代码块”的访问将被阻塞。
- 当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时,其他线程仍然可以访问“该对象”的非同步代码块。
- 当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时,其他线程对“该对象”的其他的“synchronized方法”或者“synchronized代码块”的访问将被阻塞。
举例:
class MyRunnable implements Runnable{ @Override public void run(){ synchronized(this){ try{ for(int i=0; i<5; i++){ Thread.sleep(100); System.out.println(Thread.currentThread().getName() + " loop "+i); } }catch (InterruptedException ie){ } } } } public class Test{ public static void main(String[] args){ Runnable demo = new MyRunnable(); Thread t1 = new Thread(demo, "t1"); Thread t2 = new Thread(demo, "t2"); t1.start(); t2.start(); } }
t1和t2都是基于"demo这个Runnable对象"创建的线程,我们可以将synchronized(this)中的this看作是“demo这个Runnable对象”。因此,线程t1和t2共享“demo对象的同步锁”。
结果:
t1 loop 0 t1 loop 1 t1 loop 2 t1 loop 3 t1 loop 4 t2 loop 0 t2 loop 1 t2 loop 2 t2 loop 3 t2 loop 4
但是,如果
class MyThread extends Thread{ public MyThread(String name){ super(name); } @Override public void run(){ synchronized(this){ try{ for(int i=0; i<5; i++){ Thread.sleep(100); System.out.println(Thread.currentThread().getName() + " loop "+i); } }catch (InterruptedException ie){ } } } } public class Test{ public static void main(String[] args){ Thread t1 = new MyThread("t1"); Thread t2 = new MyThread("t2"); t1.start(); t2.start(); } }
t1和t2是两个不同的MyThread对象,因此t1和t2在执行synchronized(this)时,获取的是不同对象的同步锁。
结果:
t1 loop 0 t2 loop 0 t1 loop 1 t2 loop 1 t1 loop 2 t2 loop 2 t1 loop 3 t2 loop 3 t1 loop 4 t2 loop 4
3、全局锁
如果一个线程执行一个对象的非static synchronized方法,另外一个线程需要执行这个对象所属类的static synchronized方法,此时不会发生互斥现象,因为访问static synchronized方法占用的是类锁(全局锁),而访问非static synchronized方法占用的是对象锁,所以不存在互斥现象。
pulbic class Something { public synchronized void isSyncA(){} public synchronized void isSyncB(){} public static synchronized void cSyncA(){} public static synchronized void cSyncB(){} }
假设,Something有两个实例x和y。分析下面4组表达式获取的锁的情况。
(01) x.isSyncA()与x.isSyncB()
(02) x.isSyncA()与y.isSyncA()
(03) x.cSyncA()与y.cSyncB()
(04) x.isSyncA()与Something.cSyncA()
(01) 不能被同时访问。因为isSyncA()和isSyncB()都是访问同一个对象(对象x)的同步锁!
(02) 可以同时被访问。因为访问的不是同一个对象的同步锁,x.isSyncA()访问的是x的同步锁,而y.isSyncA()访问的是y的同步锁。
(03) 不能被同时访问。因为cSyncA()和cSyncB()都是static类型,x.cSyncA()相当于Something.isSyncA(),y.cSyncB()相当于Something.isSyncB(),因此它们共用一个同步锁,不能被同时反问。
(04) 可以被同时访问。因为isSyncA()是实例方法,x.isSyncA()使用的是对象x的锁;而cSyncA()是静态方法,Something.cSyncA()可以理解对使用的是“类的锁”。因此,它们是可以被同时访问的。
注意:对于synchronized方法或者synchronized代码块,当出现异常时,JVM会自动释放当前线程占用的锁,因此不会由于异常导致出现死锁现象。
以上是关于Java 多线程的主要内容,如果未能解决你的问题,请参考以下文章