多线程
一. 多线程是什么? 为什么要使用多线程
介绍多线程之前要介绍线程,介绍线程则离不开进程。
首先 进程 :是一个正在执行中的程序,每一个进程执行都有一个执行顺序,该顺序是一个执行路径,或者叫一个控制单元;
线程:就是进程中的一个独立控制单元,线程在控制着进程的执行。一个进程中至少有一个线程。
多线程:一个进程中不只有一个线程。
为什么要用多线程:
①、为了更好的利用cpu的资源,如果只有一个线程,则第二个任务必须等到第一个任务结束后才能进行,如果使用多线程则在主线程执行任务的同时可以执行其他任务,而不需要等待;
②、进程之间不能共享数据,线程可以;
③、系统创建进程需要为该进程重新分配系统资源,创建线程代价比较小;
④、Java语言内置了多线程功能支持,简化了java多线程编程。
二. 线程的生命周期
-
新建 :从新建一个线程对象到程序start() 这个线程之间的状态,都是新建状态;
-
就绪 :线程对象调用start()方法后,就处于就绪状态,等到JVM里的线程调度器的调度;
-
运行 :就绪状态下的线程在获取CPU资源后就可以执行run(),此时的线程便处于运行状态,运行状态的线程可变为就绪、阻塞及死亡三种状态。
-
等待/阻塞/睡眠 :在一个线程执行了sleep(睡眠)、suspend(挂起)等方法后会失去所占有的资源,从而进入阻塞状态,在睡眠结束后可重新进入就绪状态。
-
终止 :run()方法完成后或发生其他终止条件时就会切换到终止状态。
阻塞状态(Blocked):处于运行状态中的线程由于某种原因,暂时放弃对CPU的使用权,停止执行,此时进入阻塞状态,直到其进入到就绪状态,才 有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同,阻塞状态又可以分为三种:
1.等待阻塞:运行状态中的线程执行wait()方法,使本线程进入到等待阻塞状态;
2.同步阻塞 – 线程在获取synchronized同步锁失败(因为锁被其它线程所占用),它会进入同步阻塞状态;
3.其他阻塞 – 通过调用线程的sleep()或join()或发出了I/O请求时,线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。
三. 创建线程的方法
1. 继承Thread类:
步骤:①、定义类继承Thread;
②、复写Thread类中的run方法;
目的:将自定义代码存储在run方法,让线程运行
③、调用线程的start方法:
该方法有两步:启动线程,调用run方法。
public class ThreadDemo1 {
public static void main(String[] args) {
//创建两个线程
ThreadDemo td = new ThreadDemo("zhangsan");
ThreadDemo tt = new ThreadDemo("lisi");
//执行多线程特有方法,如果使用td.run();也会执行,但会以单线程方式执行。
td.start();
tt.start();
//主线程
for (int i = 0; i < 5; i++) {
System.out.println("main" + ":run" + i);
}
}
}
//继承Thread类
class ThreadDemo extends Thread{
//设置线程名称
ThreadDemo(String name){
super(name);
}
//重写run方法。
public void run(){
for(int i = 0; i < 5; i++){
System.out.println(this.getName() + ":run" + i); //currentThread() 获取当前线程对象(静态)。 getName() 获取线程名称。
}
}
}
2. 实现Runnable接口:
接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run 的无参方法。
实现步骤: ①、定义类实现Runnable接口
②、覆盖Runnable接口中的run方法,将线程要运行的代码放在该run方法中。
③、通过Thread类建立线程对象。
④、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程执行指定对象的run方法就要先明确run方法所属对象
⑤、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
public class RunnableDemo {
public static void main(String[] args) {
RunTest rt = new RunTest();
//建立线程对象
Thread t1 = new Thread(rt);
Thread t2 = new Thread(rt);
//开启线程并调用run方法。
t1.start();
t2.start();
}
}
//定义类实现Runnable接口
class RunTest implements Runnable{
private int tick = 10;
//覆盖Runnable接口中的run方法,并将线程要运行的代码放在该run方法中。
public void run(){
while (true) {
if(tick > 0){
System.out.println(Thread.currentThread().getName() + "..." + tick--);
}
}
}
}
3. 通过Callable和Future创建线程:
实现步骤:
①、创建Callable接口的实现类,并实现call()方法,改方法将作为线程执行体,且具有返回值。
②、创建Callable实现类的实例,使用FutrueTask类进行包装Callable对象,FutureTask对象封装了Callable对象的call()方法的返回值
③、使用FutureTask对象作为Thread对象启动新线程。
④、调用FutureTask对象的get()方法获取子线程执行结束后的返回值。
public class CallableFutrueTest {
public static void main(String[] args) {
CallableTest ct = new CallableTest(); //创建对象
FutureTask<Integer> ft = new FutureTask<Integer>(ct); //使用FutureTask包装CallableTest对象
for(int i = 0; i < 100; i++){
//输出主线程
System.out.println(Thread.currentThread().getName() + "主线程的i为:" + i);
//当主线程执行第30次之后开启子线程
if(i == 30){
Thread td = new Thread(ft,"子线程");
td.start();
}
}
//获取并输出子线程call()方法的返回值
try {
System.out.println("子线程的返回值为" + ft.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
class CallableTest implements Callable<Integer>{
//复写call() 方法,call()方法具有返回值
public Integer call() throws Exception {
int i = 0;
for( ; i<100; i++){
System.out.println(Thread.currentThread().getName() + "的变量值为:" + i);
}
return i;
}
}
4. 使用线程池来创建线程
为什么用线程池?
1.创建/销毁线程伴随着系统开销,过于频繁的创建/销毁线程,会很大程度上影响处-理效率
2.线程并发数量过多,抢占系统资源从而导致阻塞
3.对线程进行一些简单的管理
在Java中,线程池的概念是Executor这个接口,具体实现为ThreadPoolExecutor类,学习Java中的线程池,就可以直接学习他了对线程池的配置,就是对ThreadPoolExecutor构造函数的参数的配置
4.1 ThreadPoolExecutor提供了四个构造函数
//五个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue)
//六个参数的构造函数-1
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory)
//六个参数的构造函数-2
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler)
//七个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
下面来解释下各个参数:
- int corePoolSize:该线程池中核心线程数最大值
核心线程:线程池新建线程的时候,如果当前线程总数小于corePoolSize,则新建的是核心线程,如果超过corePoolSize,则新建的是非核心线程核心线程默认情况下会一直存活在线程池中,即使这个核心线程啥也不干(闲置状态)。
如果指定ThreadPoolExecutor的allowCoreThreadTimeOut这个属性为true,那么核心线程如果不干活(闲置状态)的话,超过一定时间(时长下面参数决定),就会被销毁掉。
- int maximumPoolSize: 该线程池中线程总数最大值
线程总数 = 核心线程数 + 非核心线程数。
- long keepAliveTime:该线程池中非核心线程闲置超时时长
一个非核心线程,如果不干活(闲置状态)的时长超过这个参数所设定的时长,就会被销毁掉,如果设置allowCoreThreadTimeOut = true,则会作用于核心线程。
- TimeUnit unit:keepAliveTime的单位
TimeUnit是一个枚举类型,其包括:
NANOSECONDS : 1微毫秒 = 1微秒 / 1000
MICROSECONDS : 1微秒 = 1毫秒 / 1000
MILLISECONDS : 1毫秒 = 1秒 /1000
SECONDS : 秒
MINUTES : 分
HOURS : 小时
DAYS : 天
- BlockingQueue workQueue:该线程池中的任务队列:维护着等待执行的Runnable对象
当所有的核心线程都在干活时,新添加的任务会被添加到这个队列中等待处理,如果队列满了,则新建非核心线程执行任务。
常用的workQueue类型:
- SynchronousQueue:这个队列接收到任务的时候,会直接提交给线程处理,而不保留它,如果所有线程都在工作怎么办?那就新建一个线程来处理这个任务!所以为了保证不出现<线程数达到了maximumPoolSize而不能新建线程>的错误,使用这个类型队列的时候,
maximumPoolSize一般指定成Integer.MAX_VALUE,即无限大
-
LinkedBlockingQueue:这个队列接收到任务的时候,如果当前线程数小于核心线程数,则新建线程(核心线程)处理任务;如果当前线程数等于核心线程数,则进入队列等待。由于这个队列没有最大值限制,即所有超过核心线程数的任务都将被添加到队列中,这也就导致了maximumPoolSize的设定失效,因为总线程数永远不会超过corePoolSize
-
ArrayBlockingQueue:可以限定队列的长度,接收到任务的时候,如果没有达到corePoolSize的值,则新建线程(核心线程)执行任务,如果达到了,则入队等候,如果队列已满,则新建线程(非核心线程)执行任务,又如果总线程数到了maximumPoolSize,并且队列也满了,则发生错误
-
DelayQueue:队列内元素必须实现Delayed接口,这就意味着你传进去的任务必须先实现Delayed接口。这个队列接收到任务时,首先先入队,只有达到了指定的延时时间,才会执行任务
-
ThreadFactory threadFactory:创建线程的方式,这是一个接口,你new他的时候需要实现他的Thread newThread(Runnable r)方法,一般用不上。
-
RejectedExecutionHandler handler:这玩意儿就是抛出异常专用的,比如上面提到的两个错误发生了,就会由这个handler抛出异常,根本用不上。
4.2 向ThreadPoolExecutor添加任务
我们怎么知道new一个ThreadPoolExecutor,大概知道各个参数是干嘛的,可是我new完了,怎么向线程池提交一个要执行的任务啊?
ThreadPoolExecutor.execute(Runnable command)
通过ThreadPoolExecutor.execute(Runnable command)方法即可向线程池内添加一个任务。
4.3 ThreadPoolExecutor的策略
这里给总结一下,当一个任务被添加进线程池时,执行策略:
1.线程数量未达到corePoolSize,则新建一个线程(核心线程)执行任务
2.线程数量达到了corePools,则将任务移入队列等待
3.队列已满,新建线程(非核心线程)执行任务
4.队列已满,总线程数又达到了maximumPoolSize,就会由(RejectedExecutionHandler)抛出异常
4.4 常见四种线程池:
如果你不想自己写一个线程池,Java通过Executors提供了四种线程池,这四种线程池都是直接或间接配置ThreadPoolExecutor的参数实现的。
4.4.1 可缓存线程池CachedThreadPool()
源码:
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
根据源码可以看出:
- 这种线程池内部没有核心线程,线程的数量是有没限制的。
- 在创建任务时,若有空闲的线程时则复用空闲的线程,若没有则新建线程。
- 没有工作的线程(闲置状态)在超过了60S还不做事,就会销毁。
创建方法:
ExecutorService mCachedThreadPool = Executors.newCachedThreadPool();
用法:
private void startDownload(final ProgressBar progressBar, final int i) {
mCachedThreadPool.execute(new Runnable() {
@Override
public void run() {
int p = 0;
progressBar.setMax(10);//每个下载任务10秒
while (p < 10) {
p++;
progressBar.setProgress(p);
Bundle bundle = new Bundle();
Message message = new Message();
bundle.putInt("p", p);
//把当前线程的名字用handler让textview显示出来
bundle.putString("ThreadName", Thread.currentThread().getName());
message.what = i;
message.setData(bundle);
mHandler.sendMessage(message);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
}
4.4.2 FixedThreadPool 定长线程池
源码:
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
根据源码可以看出:
- 该线程池的最大线程数等于核心线程数,所以在默认情况下,该线程池的线程不会因为闲置状态超时而被销毁。
- 如果当前线程数小于核心线程数,并且也有闲置线程的时候提交了任务,这时也不会去复用之前的闲置线程,会创建新的线程去执行任务。如果当前执行任务数大于了核心线程数,大于的部分就会进入队列等待。等着有闲置的线程来执行这个任务。
创建方法:
//nThreads => 最大线程数即maximumPoolSize
ExecutorService mFixedThreadPool= Executors.newFixedThreadPool(int nThreads);
//threadFactory => 创建线程的方法,用得少
ExecutorService mFixedThreadPool= Executors.newFixedThreadPool(int nThreads, ThreadFactory threadFactory);
用法:
private void startDownload(final ProgressBar progressBar, final int i) {
mFixedThreadPool.execute(new Runnable() {
@Override
public void run() {
//....逻辑代码自己控制
}
});
}
4.4.3 SingleThreadPool
源码:
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
根据源码可以看出:
- 有且仅有一个工作线程执行任务
- 所有任务按照指定顺序执行,即遵循队列的入队出队规则
创建方法:
ExecutorService mSingleThreadPool = Executors.newSingleThreadPool();
用法同上。
4.4.4 ScheduledThreadPool
源码:
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
//ScheduledThreadPoolExecutor():
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE,
DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
new DelayedWorkQueue());
}
根据源码可以看出:
DEFAULT_KEEPALIVE_MILLIS就是默认10L,这里就是10秒。这个线程池有点像是吧CachedThreadPool和FixedThreadPool 结合了一下。
- 不仅设置了核心线程数,最大线程数也是Integer.MAX_VALUE。
- 这个线程池是上述4个中为唯一个有延迟执行和周期执行任务的线程池。
创建:
//nThreads => 最大线程数即maximumPoolSize
ExecutorService mScheduledThreadPool = Executors.newScheduledThreadPool(int corePoolSize);
一般的执行任务方法和上面的都大同小异,我们主要看看延时执行任务和周期执行任务的方法。
//表示在3秒之后开始执行我们的任务。
mScheduledThreadPool.schedule(new Runnable() {
@Override
public void run() {
//....
}
}, 3, TimeUnit.SECONDS);
//延迟3秒后执行任务,从开始执行任务这个时候开始计时,每7秒执行一次不管执行任务需要多长的时间。
mScheduledThreadPool.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
//....
}
},3, 7, TimeUnit.SECONDS);
/**延迟3秒后执行任务,从任务完成时这个时候开始计时,7秒后再执行,
*再等完成后计时7秒再执行也就是说这里的循环执行任务的时间点是
*从上一个任务完成的时候。
*/
mScheduledThreadPool.scheduleWithFixedDelay(new Runnable() {
@Override
public void run() {
//....
}
},3, 7, TimeUnit.SECONDS);
四. 继承Thread类和实现Runnable接口、实现Callable接口的区别
继承Thread:线程代码存放在Thread子类run方法中。
优势:编写简单,可直接用this.getname()获取当前线程,不必使用Thread.currentThread()方法。
劣势:已经继承了Thread类,无法再继承其他类。
实现Runnable接口:线程代码存放在接口的子类的run方法中。
优势:避免了单继承的局限性、多个线程可以共享一个target对象,非常适合多线程处理同一份资源的情形。
劣势:比较复杂、访问线程必须使用Thread.currentThread()方法、无返回值。
实现Callable接口:
优势:有返回值、避免了单继承的局限性、多个线程可以共享一个target对象,非常适合多线程处理同一份资源的情形。
劣势:比较复杂、访问线程必须使用Thread.currentThread()方法
建议使用实现接口的方式创建多线程
五. 线程状态管理
1. 线程睡眠 — sleep
线程睡眠的原因:线程执行的太快,或需要强制执行到下一个线程。
线程睡眠的方法(两个):sleep(long millis)在指定的毫秒数内让正在执行的线程休眠。
sleep(long millis,int nanos)在指定的毫秒数加指定的纳秒数内让正在执行的线程休眠。
\线程睡眠的代码演示:
public class SynTest {
public static void main(String[] args) {
new Thread(new CountDown(),"倒计时").start();
}
}
class CountDown implements Runnable{
int time = 10;
public void run() {
while (true) {
if(time>=0){
System.out.println(Thread.currentThread().getName() + ":" + time--);
try {
Thread.sleep(1000); //睡眠时间为1秒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
每隔一秒则会打印一次,打印结果为:
倒计时:10
倒计时:9
倒计时:8
倒计时:7
倒计时:6
倒计时:5
倒计时:4
倒计时:3
倒计时:2
倒计时:1
倒计时:0
扩展:Java线程调度是Java多线程的核心,只有良好的调度,才能充分发挥系统的性能,提高程序的执行效率。但是不管程序员怎么编写调度,只能最大限度的影响线程执行的次序,而不能做到精准控制。因为使用sleep方法之后,线程是进入阻塞状态的,只有当睡眠的时间结束,才会重新进入到就绪状态,而就绪状态进入到运行状态,是由系统控制的,我们不可能精准的去干涉它,所以如果调用Thread.sleep(1000)使得线程睡眠1秒,可能结果会大于1秒。
2. 线程让步 — yield
该方法和sleep方法类似,也是Thread类提供的一个静态方法,可以让正在执行的线程暂停,但是不会进入阻塞状态,而是直接进入就绪状态。相当于只是将当前线程暂停一下,然后重新进入就绪的线程池中,让线程调度器重新调度一次。也会出现某个线程调用yield方法后暂停,但之后调度器又将其调度出来重新进入到运行状态。
public class SynTest {
public static void main(String[] args) {
yieldDemo ms = new yieldDemo();
Thread t1 = new Thread(ms,"张三吃完还剩");
Thread t2 = new Thread(ms,"李四吃完还剩");
Thread t3 = new Thread(ms,"王五吃完还剩");
t1.start();
t2.start();
t3.start();
}
}
class yieldDemo implements Runnable{
int count = 20;
public void run() {
while (true) {
if(count>0){
System.out.println(Thread.currentThread().getName() + count-- + "个瓜");
if(count % 2 == 0){
Thread.yield(); //线程让步
}
}
}
}
}
sleep和yield的区别:
①、sleep方法声明抛出InterruptedException,调用该方法需要捕获该异常。yield没有声明异常,也无需捕获。
②、sleep方法暂停当前线程后,会进入阻塞状态,只有当睡眠时间到了,才会转入就绪状态。而yield方法调用后 ,是直接进入就绪状态。
3. 线程合并 — join
当B线程执行到了A线程的.join()方法时,B线程就会等待,等A线程都执行完毕,B线程才会执行。join可以用来临时加入线程执行。
以下为代码演示:
public static void main(String[] args) throws InterruptedException {
yieldDemo ms = new yieldDemo();
Thread t1 = new Thread(ms,"张三吃完还剩");
Thread t2 = new Thread(ms,"李四吃完还剩");
Thread t3 = new Thread(ms,"王五吃完还剩");
t1.start();
t1.join();
t2.start();
t3.start();
System.out.println( "主线程");
}
4. 停止线程
原stop方法因有缺陷已经停用了,那么现在改如何停止线程?现在分享一种,就是让run方法结束。
开启多线程运行,运行的代码通常是循环结构,只要控制住循环,就可以让run方法结束,也就是线程结束。
具体代码如下:
public class StopThread {
public static void main(String[] args) {
int num = 0;
StopTh st = new StopTh();
Thread t1 = new Thread(st);
Thread t2 = new Thread(st);
t1.start();
t2.start();
//设置主线程执行50次,执行结束之后停止线程
while (true) {
if(num++ == 50){
st.flagChange();
break;
}
System.out.println(Thread.currentThread().getName() + "..." + num);
}
}
}
class StopTh implements Runnable{
private boolean flag = true;
public void run() {
while(flag){
System.out.println(Thread.currentThread().getName() + "stop run" );
}
}
public void flagChange(){
flag = false;
}
}
特殊情况:当线程处于了冻结状态,就不会读取到标记,也就不会结束。当没有指定方法让冻结的线程回复到运行状态时,我们需要对冻结状态进行清除,也就是强制让线程恢复到运行状态中来,这样可就可以操作标记让线程结束。
Thread类提供该方法: interrupt();(如果线程在调用Object类的wait()、wait(long)、wait(long,int)方法,或者该类的join()、join(long)、join(long、int)、sleep(long)或sleep(long、int)方法过程中受阻,则其中断状态将被清除,还将收到一个InterruptedException。)
5. 设置优先级
每个线程执行时都有一个优先级的属性,优先级高的线程可以获得较多的执行机会,而优先级低的线程则获得较少的执行机会。与线程休眠类似,线程的优先级仍然无法保障线程的执行次序。只不过,优先级高的线程获取CPU资源的概率较大,优先级低的也并非没机会执行。
Thread类中提供了优先级的三个常量,代码如下:
MAX_PRIORITY = 10
MIN_PRIORITY = 1
NORM_PRIORITY = 5
ThreadDemo td = new ThreadDemo();
Thread t1 = new Thread(td,"张三"); t1.priority(9); //设置优先级
t1.start();//设置完毕
六. 线程同步与锁
为什么要进行线程同步?
java允许多线程并发控制,当多个线程同时操作一个可共享资源变量时(如对其进行增删改查操作),会导致数据不准确,而且相互之间产生冲突。所以加入同步锁以避免该线程在没有完成操作前被其他线程调用,从而保证该变量的唯一性和准确性。
不同步会发生的问题?
在介绍同步方法之前先演示一下当多个线程操作一个共享资源时可能会发生的错误,这里用的方法是让线程在执行时睡眠10毫秒,会导致多个线程去操作同一个资源变量:
public class SynTest {
public static void main(String[] args) {
//定义三个线程,
MySyn ms = new MySyn();
Thread t1 = new Thread(ms,"线程1输出:");
Thread t2 = new Thread(ms,"线程2输出:");
Thread t3 = new Thread(ms,"线程3输出:");
t1.start();
t2.start();
t3.start();
}
}
class MySyn implements Runnable{
int tick = 10; //共执行10次线程
public void run() {
while(true){
if(tick>0){
try {
Thread.sleep(10); //执行中让线程睡眠10毫秒,
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " " + tick--);
}
}
}
}
输出结果用以下图片展示,可以看到我勾选的部分都发生了冲突数据:
同步方法1:
同步函数:就是用synchronize关键字修饰的方法。因为每个java对象都有一个内置锁,当用synchronize关键字修饰方法时内置锁会保护整个方法,而在调用该方法之前,要先获得内置锁,否则就会处于阻塞状态。
代码演示:请将上方代码的第17行改为以下代码↓
public synchronized void run() {
同步方法2:
同步代码块:就是拥有synchronize关键字修饰的语句块,被该关键字修饰的语句块会自动被加上内置锁,从而实现同步。
代码演示:将上方代码的run方法改成下方代码
public void run() {
while(true){
synchronized (this) { //同步代码块
if(tick>0){
try {
Thread.sleep(10); //执行中让线程睡眠10毫秒,
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " " + tick--);
}
}
}
}
加同步之后的输出数据为:
线程1输出: 10
线程2输出: 9
线程2输出: 8
线程2输出: 7
线程2输出: 6
线程2输出: 5
线程2输出: 4
线程3输出: 3
线程3输出: 2
线程3输出: 1
追加问题:如果同步函数被静态修饰之后,使用的锁是什么?静态方法中不能定义this!
静态内存是:内存中没有本类对象,但是一定有该类对应的字节码文件对象。 类名.class 该对象类型是Class。
所以静态的同步方法使用的锁是该方法所在类的字节码文件对象。 类名.class。代码如下:
public static mySyn(String name){
synchronized (Xxx.class) {
Xxx.name = name;
}
}
--------------------------------以下是总结-----------------------------------
同步的前提:
1、必须要有两个或者两个以上的线程。
2、必须是多个线程使用同一个锁。
3、必须保证同步中只能有一个线程在运行。
4、只能同步方法,不能同步变量和类。
5、不必同步类中所有方法,类可以拥有同步和非同步的方法。
6、如果一个线程在对象上获得一个锁,就没有任何其他线程可以进入(该对象的)类中的任何一个同步方法。
7、线程睡眠时,它所持的任何锁都不会释放。
好处:解决了多线程的安全问题。
弊端:多个线程需要判断,消耗资源,降低效率。
如何找问题?
1、明确哪些代码是多线程运行代码。
2、明确共享数据。
3、明确多线程运行代码中哪些语句是操作共享数据的。
七. 死锁
进程A中包含资源A,进程B中包含资源B,A的下一步需要资源B,B的下一步需要资源A,所以它们就互相等待对方占有的资源释放,所以也就产生了一个循环等待死锁。
public class DeadLock {
public static void main(String[] args) {
Thread t1 = new Thread(new DeadLockTest(true));
Thread t2 = new Thread(new DeadLockTest(false));
t1.start();
t2.start();
}
}
class DeadLockTest implements Runnable{
private boolean flag;
static Object obj1 = new Object();
static Object obj2 = new Object();
public DeadLockTest(boolean flag) {
this.flag = flag;
}
public void run(){
if(flag){
synchronized(obj1){
System.out.println("if lock1");
synchronized (obj2) {
System.out.println("if lock2");
}
}
}else{
synchronized (obj2) {
System.out.println("else lock2");
synchronized (obj1) {
System.out.println("else lock1");
}
}
}
}
}
死锁形成的必要条件总结(都满足之后就会产生):
①、互斥条件:资源不能被共享,只能被同一个进程使用;
②、请求与保持条件:已经得到资源的进程可以申请新的资源;
③、非剥夺条件:已经分配的资源不能从相应的进程中强制剥夺;
④、循环等待条件:系统中若干进程形成环路,该环路中每个进程都在等待相邻进程占用的资源。
八. 线程间的通信,等待唤醒机制
示例:
package com.hk.java.thread;
/**
* 两个线程交替输出30以内的奇数偶数
*
* @author 浪丶荡
*
*/
public class PrintOddEven implements Runnable {
@Override
public void run() {
for (int i = 0; i <= 31; i++) {
if(i==31){//如果为31,强制结束程序
System.exit(0);
}
//名为张三的线程负责输出偶数
if (Thread.currentThread().getName().equals("张三")) {
synchronized (this) {
if (i % 2 == 0) {
System.out.println("[ "
+ Thread.currentThread().getName() + " ]打印偶数 "
+ i);
notify();// 唤醒李四
try {
wait();// 当前线程(张三)放弃执行资格,等待,直到被其他线程唤醒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//名为李四的线程负责输出奇数
if (Thread.currentThread().getName().equals("李四")) {
synchronized (this) {
if (i % 2 == 1) {
System.out.println("[ "
+ Thread.currentThread().getName() + " ]打印奇数 "
+ i);
notify();//唤醒张三
try {
wait();// 当前线程(李四)放弃执行资格,等待,直到被其他线程唤醒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
}
测试类:
public static void main(String[] args) {
PrintOddEven thereThread = new PrintOddEven();
Thread thread = new Thread(thereThread);
thread.setName("张三");
thread.start();
Thread threa = new Thread(thereThread);
threa.setName("李四");
threa.start();
}
结果:
[ 张三 ]打印偶数 0
[ 李四 ]打印奇数 1
[ 张三 ]打印偶数 2
[ 李四 ]打印奇数 3
[ 张三 ]打印偶数 4
[ 李四 ]打印奇数 5
[ 张三 ]打印偶数 6
[ 李四 ]打印奇数 7
[ 张三 ]打印偶数 8
[ 李四 ]打印奇数 9
[ 张三 ]打印偶数 10
[ 李四 ]打印奇数 11
[ 张三 ]打印偶数 12
[ 李四 ]打印奇数 13
[ 张三 ]打印偶数 14
[ 李四 ]打印奇数 15
[ 张三 ]打印偶数 16
[ 李四 ]打印奇数 17
[ 张三 ]打印偶数 18
[ 李四 ]打印奇数 19
[ 张三 ]打印偶数 20
[ 李四 ]打印奇数 21
[ 张三 ]打印偶数 22
[ 李四 ]打印奇数 23
[ 张三 ]打印偶数 24
[ 李四 ]打印奇数 25
[ 张三 ]打印偶数 26
[ 李四 ]打印奇数 27
[ 张三 ]打印偶数 28
[ 李四 ]打印奇数 29
[ 张三 ]打印偶数 30
分析:
notify:唤醒,唤醒对方,当线程池有多个线程出于等待状态时,则会选择唤醒其中一个线程。选择是任意性的,并在对实现做出决定时发生。
wait:此方法导致当前线程,将其自身放置在对象的等待集中,然后放弃此对象上的所有同步要求,也就是放弃执行权,释放占有的资源,直到被其他线程唤醒。