------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流! ----------
一、多线程
1.1 线程
进程:是一个正在执行中的程序,每一个进程执行都有一个执行顺序,该顺序是一个执行路径或者叫控制单元。
线程:就是进程中的一个独立的控制单元,线程在控制着进程的执行。
理解线程:
1. 一个进程中至少有一个线程
2. JVM 启动的时候会有一个进程java.exe
该进程中至少有一个线程在负责java程序的执行,而且这个线程运行的代码存在于main方法中,该线程称为主线程;同时还会启动垃圾回收线程。
3. 开启多个线程是为了同时运行多部分代码,每一个线程都有自己运行的内容,这个内容可以称为线程要执行的任务。
多线程的好处:解决了多部分代码同时运行的问题。
多线程的弊端:线程太多,会导致效率的降低。
1.2 创建线程
1.2.1 继承Thread类
创建方式:
1. 定义一个类继承Thread类。
2. 覆盖Thread类中的run方法。
3. 直接创建Thread的子类对象创建线程。
4. 调用start方法开启线程,该方法有两个作用,启动线程,调用run方法。
为什么要覆盖run方法?
Thread 类用于描述线程
该类定义了一个功能用于存储线程要运行的代码,就是run方法,run方法用于存储线程中要运行的代码
class Demo extends Thread { public void run() { System.out.println("demo run"); } } class ThreadDemo { public static void main(String[] args) { Demo d = new Demo(); //创建好一个线程 d.start();//开启线程并执行该线程的run方法 //d.run() 仅仅是对象调用方法,主线程在运行它,新创建的进程没有运行 } }
P.S.
1、可以通过Thread的getName方法获取线程的名称,名称格式:Thread-编号(从0开始)。
2、Thread在创建的时候,该Thread就已经命名了。
1.2.2 实现Runnable 接口
创建方式:
1.定义类实现Runnable接口
2.覆盖Runnable接口中的run方法,将线程要运行的代码存放在run方法中
3.通过Thread类建立线程对象
4.将Runnable接口的子类对象作为实际参数传递给Tread类的构造函数
5.调用Thread类的start方法开启线程并调用Runnable接口子类的run方法
class ThreadDemo { public static void main(String[] args) { Thread t1 = new Thread(new Run()); t1.start(); for(int y=0;y<10;y++) { System.out.println(Thread.currentThread().getName()+" y="+y); } } } class Run implements Runnable { public void run() { for(int x=0;x<10;x++) { System.out.println(Thread.currentThread().getName()+" x="+x); } } }
每次运行打印的顺序都不一样。
实现方式与继承方式有什么区别
继承Thread:线程代码存放在Thread子类run方法中
实现Runnable:线程代码存放在接口子类的run方法中
实现:避免类单继承的局限性,在定义线程时建议使用实现方式
实现Runnable接口的好处:
1. 将线程的任务从线程的子类中分离出来,进行了单独的封装,按照面向对象的思想将任务封装成对象。
2. 避免了Java单继承的局限性。 所以,创建线程的第二种方式较为常用。
1.3 线程的安全问题
当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行到一部分,另一个线程参与进来,导致共享数据错误
解决办法:操作共享数据时,让一个线程执行完,其他线程再开始执行
1.3.1 java解决办法:同步代码块(锁)
synchronized(对象) { 需要被同步的代码 }
同步的前提
1.必须有两个以上的线程
2.必须是多个线程使用同一个锁
好处:解决了安全问题
弊端:需要判断锁,较为消耗资源
练习:实现一个卖票程序
class Ticket implements Runnable { public int tic = 100; Object obj = new Object(); public void run() { while(true) { synchronized(obj) { if(tic>0) { try { Thread.sleep(10); //睡眠再去执行程序可能出现问题 } catch(Exception e) { } System.out.println(Thread.currentThread().getName()+"..sale:"+tic--); } } } } } class ThreadTest1 { public static void main(String[] args) { Ticket t = new Ticket(); Thread t1 = new Thread(t); Thread t2 = new Thread(t); Thread t3 = new Thread(t); Thread t4 = new Thread(t); t1.start(); t2.start(); t3.start(); t4.start(); } }
结果分析:
Object对象相当于是一把锁,只有抢到锁的线程,才能进入同步代码块向下执行。 因此,当tic=1时,CPU切换到某个线程后,如上图的Thread-3线程,其他线程将无法通过同步代码块继而进行if判断语句,只有等到Thread-3线程执行完“tic--” 操作(此后tic的值为0),并且跳出同步代码块后,才能抢到锁。 其他线程即使抢到锁,然而,此时tic值已为0,也就无法通过if语句判断,从而无法再执行“ tic--” 的操作了,也就不会出现0、 -1、 -2等情况了。
1.3.2 同步函数:用synchronized修饰操作共享数据的函数
练习:模拟银行存钱代码
class Bank { private int sum; Object obj = new Object(); public synchronized void add(int n)//同步函数 { //synchronized(obj) //{ sum = sum + n; System.out.println("sum="+sum); //} } } class Cun implements Runnable { private Bank b = new Bank(); public void run() { for(int x=0; x<3; x++) { b.add(100); } } } class ThreadTest2 { public static void main(String[] args) { Cun c = new Cun(); Thread t1 = new Thread(c); Thread t2 = new Thread(c); t1.start(); t2.start(); } }
同步函数和同步代码块的区别:
1. 同步函数的锁是固定的this。
2. 同步代码块的锁是任意的对象。
建议使用同步代码块。
1.3.3 静态函数的同步
被静态修饰的同步函数,通过验证,使用的锁不是this,因为静态方法中也不可以定义this
静态的同步函数,使用的锁是该方法所在类的字节码文件对象:类名.class
多线程下的单例模式,饿汉式不存在安全问题,懒汉式的安全问题可以如下解决
class Single { private static Single s = null; private Single(){} public static Single getInstance() { if(s==null) { synchronized(Single.class) } if(s==null) s = new Single(); } } return s; } } class SingleDemo { public static void main(String[] args) { Single s = Single.getInstance(); } }
1.3.4 死锁
死锁常见情景之一:同步的嵌套
//定义一个类来实现Runnable,并复写run方法 /* 死锁:同步中嵌套同步 */ class Test implements Runnable { private boolean flag; Test (boolean flag) { this.flag = flag; } public void run() { if(flag) { synchronized(mylock.obj1) { System.out.println("if obj1"); synchronized(mylock.obj2) { System.out.println("if obj2"); } } } else { synchronized(mylock.obj2) { System.out.println("else obj2"); synchronized(mylock.obj1) { System.out.println("else obj1"); } } } } } class mylock { static Object obj1 = new Object(); static Object obj2 = new Object(); } class DeadLockTest { public static void main(String[] args) { Thread t1 = new Thread(new Test(true)); Thread t2 = new Thread(new Test(false)); t1.start(); t2.start(); } }
程序处于等待状态,形成死锁
1.4 线程间的通讯
多个线程在处理统一资源,但是任务却不同,这时候就需要线程间通信。
等待/唤醒机制涉及的方法:
1. wait():让线程处于冻结状态,被wait的线程会被存储到线程池中。
2. notify():唤醒线程池中的一个线程(任何一个都有可能)。
3. notifyAll():唤醒线程池中的所有线程
注意:
1、这些方法都必须定义在同步中,因为这些方法是用于操作线程状态的方法。
2、必须要明确到底操作的是哪个锁上的线程!
3、wait和sleep区别?
1)wait可以指定时间也可以不指定。sleep必须指定时间。
2)在同步中时,对CPU的执行权和锁的处理不同。
wait:释放执行权,释放锁。
sleep:释放执行权,不释放锁。
1.5 JDK1.5新特性
同步代码块就是对于锁的操作是隐式的。
JDK1.5以后将同步和锁封装成了对象,并将操作锁的隐式方式定义到了该对象中,将隐式动作变成了
显示动作。
Lock接口:出现替代了同步代码块或者同步函数,将同步的隐式操作变成显示锁操作。同时更为灵
活,可以一个锁上加上多组监视器。
lock():获取锁。
unlock():释放锁,为了防止异常出现,导致锁无法被关闭,所以锁的关闭动作要放在finally中。
Condition接口:出现替代了Object中的wait、notify、notifyAll方法。将这些监视器方法单独进行了
封装,变成Condition监视器对象,可以任意锁进行组合。
Condition接口中的await方法对应于Object中的wait方法。
Condition接口中的signal方法对应于Object中的notify方法。
Condition接口中的signalAll方法对应于Object中的notifyAll方法
/* 生产者生产商品,供消费者使用 有两个或者多个生产者,生产一次就等待消费一次 有两个或者多个消费者,等待生产者生产一次就消费掉 */ import java.util.concurrent.locks.*; class Resource { private String name; private int count=1; private boolean flag = false; //多态 private Lock lock=new ReentrantLock(); //创建两Condition对象,分别来控制等待或唤醒本方和对方线程 Condition condition_pro=lock.newCondition(); Condition condition_con=lock.newCondition(); //p1、p2共享此方法 public void setProducer(String name)throws InterruptedException { lock.lock();//锁 try { while(flag)//重复判断标识,确认是否生产 condition_pro.await();//本方等待 this.name=name+"......"+count++;//生产 System.out.println(Thread.currentThread().getName()+"...生产..."+this.name);//打印生产 flag=true;//控制生产\消费标识 condition_con.signal();//唤醒对方 } finally { lock.unlock();//解锁,这个动作一定执行 } } //c1、c2共享此方法 public void getConsumer()throws InterruptedException { lock.lock(); try { while(!flag)//重复判断标识,确认是否可以消费 condition_con.await(); System.out.println(Thread.currentThread().getName()+".消费."+this.name);//打印消费 flag=false;//控制生产\消费标识 condition_pro.signal(); } finally { lock.unlock(); } } } //生产者线程 class Producer implements Runnable { private Resource res; Producer(Resource res) { this.res=res; } //复写run方法 public void run() { while(true) { try { res.setProducer("商品"); } catch (InterruptedException e) { } } } } //消费者线程 class Consumer implements Runnable { private Resource res; Consumer(Resource res) { this.res=res; } //复写run public void run() { while(true) { try { res.getConsumer(); } catch (InterruptedException e) { } } } } class ProducerConsumer { public static void main(String[] args) { Resource res=new Resource(); new Thread(new Producer(res)).start();//第一个生产线程 p1 new Thread(new Consumer(res)).start();//第一个消费线程 c1 new Thread(new Producer(res)).start();//第二个生产线程 p2 new Thread(new Consumer(res)).start();//第二个消费线程 c2 } }
1.6 停止线程
如何停止线程?
只有一种方法,run方法结束。
启动多线程运行,运行代码通常是循环结构只要控制循环,就可以让run方法结束,也就是线程结束。
特殊情况:
当线程处于冻结状态,就不会读取到标记,那么线程就不会结束。
当没有指定的方式让冻结的线程回复到运行状态时,就需要对冻结进行清除,强制让线程恢复到运行状态中来,这样就可以操作标记让线程结束interrupt()。
class StopThread implements Runnable { private boolean Flag = true; public void run() { while(Flag) { System.out.println(Thread.currentThread().getName()+"..run"); } } public void changeFlag() { Flag = false; } } class StopThreadDemo { public static void main(String[] args) { StopThread st = new StopThread(); Thread t1 = new Thread(st); Thread t2 = new Thread(st); t1.setDaemon(true); t2.setDaemon(true); t1.start(); t2.start(); int num = 0; while (true) { if(num++ == 60) { break; } System.out.println(Thread.currentThread().getName()+"..."+num); } } }
1.7 操作线程的其他方法
1.join:当A线程执行到B线程的,join()方法时,A就会等待,等到B线程都执行完,A才会执行。join可以用来临时加入线程执行。class Demo implements Runnable { public void run() { for(int x=0; x<70; x++) { System.out.println(Thread.currentThread().toString()+"...."+x); Thread.yield();//暂停当前正在执行的线程对象,并执行其他线程,可以是线程交替运行 } } } class JoinDemo { public static void main(String[] args) throws Exception { Demo d = new Demo(); Thread t1 = new Thread(d); Thread t2 = new Thread(d); t1.start(); //t1.join(); t1要求加入运算,主线程释放运算权,直到t1结束, //主线程开始执行下面的代码,t2开始执行 t2.start(); t2.setPriority(Thread.MAX_PRIORITY); //t1.join(); //join 要求加入运算,主线程释放执行权 //此时t1与t2交替运行,直到t1运算结束,主线程开始执行 for(int x=0; x<80; x++) { System.out.println("main..."+x); } System.out.println("over"); } }
2、setPriority()方法用来设置优先级
MAX_PRIORITY 最高优先级10
MIN_PRIORITY 最低优先级1
NORM_PRIORITY 分配给线程的默认优先级
3、yield()方法可以暂停当前线程,让其他线程执行。