学习笔记四、多线程
1、多线程
1.1进程+线程
进程:是正在运行的程序
是系统进行资源分配和调用的独立空间
每一个进程都有它自己的内存空间和系统资源‘
线程:是进程中的单个顺序控制流,是一条执行路径
单线程:一个进程如果只有一条执行路径,则称为单线程程序/
多线程:一个进程如果由多条执行路径,是多线程程序
1.2 多线程的实现方式
方式一、继承Thread类
定义一个类myThread继承Thread类
再myThread类中重写run()方法
创建mythread类的对象
启动线程
两个小问题:
1、为什么要重写run()方法?
因为run()是用来封装被线程执行的代码
2、run()和start()方法的区别?
run():封装线程执行的代码,直接调用,相当于普通方法的调用
start():启动线程,然后由JVM调用此线程的run()方法
public static void main(String[] args) { mythread my1 = new mythread(); mythread my2 = new mythread(); // my1.run(); // my2.run();//不是多线程,是第一个执行完了,才执行第二个。 //直接调用run方法,不是线程开hi执行 my1.start(); my2.start();//这是多线程,同时再跑 }
public class mythread extends Thread{ @Override public void run() { for (int i=0;i<100;i++){ System.out.println(i); } } }
1.3 设置和获取线程名称
Thread类中设置和获取线程名称的方法:
void setName(String name):将此线程的名称更改为等于参数name
String getName():返回此线程的名称
通过构造方法设置线程名称;
如何获取main()方法所在线程名称?
static Thread currentThread():返回对当前正在执行的线程对象的引用
sout(Thread.currentThread().getName());
main
public static void main(String[] args) { mythread my1 = new mythread(); mythread my2 = new mythread(); //my1.setName("zzzzz"); //my2.setName("阿萨"); my1.start(); my2.start(); } mythread my1 = new mythread("zzzzz"); mythread my2 = new mythread("阿萨");
public class mythread extends Thread{ public mythread() { } public mythread(String name) { super(name); } @Override public void run() { for (int i=0;i<100;i++){ System.out.println(getName()+":"+i); } }
1.4 线程调度
线程由两种调度模型:
分时调度模型:所有线程轮流使用cpu的使用权,平均分配每个线程占用CPU的时间片
抢占式调度模型:优先让优先级高的线程使用CPU,如果线程的优先级相同,那么会随机选择一个,优先级高的线程获取的CPU时间片相对多一些。
java使用的是抢占式调度模型
方法:
public final int getPriority():返回此线程的优先级
public final int setPriority(int newPriority):更改此线程的优先级,里面的值1-10,默认5。10是最高的优先级
优先级高,仅仅表示线程获取的CPU时间片的几率高,但是要在次数比较多,或者多次运行的时候才能看到你想要的效果。
public static void main(String[] args) { mythread my1 = new mythread("zzzzz"); mythread my2 = new mythread("阿萨");//1 mythread my3 = new mythread("aaaaaa"); my1.setPriority(10);//优先级高 my2.setPriority(1); my3.setPriority(5); System.out.println(my1.getPriority());//5,默认5 System.out.println(my2.getPriority()); System.out.println(my3.getPriority()); my1.start(); my2.start(); my3.start();
1.5 线程控制
static void sleep(long millis):使当前正在执行的线程停留(暂停执行)指定的毫秒数
void join():等待这个线程死亡。当一个线程调用了join方法,其他的线程必须等待这个线程执行完毕,才能继续执行。
void setDaemon(boolean on):将此线程标记为守护线程,当运行的线程都是守护线程的时候,java虚拟机将退出。
try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace();//在子类中 } my1.start(); try { my1.join();//在测试类中 } catch (InterruptedException e) { e.printStackTrace(); }
public static void main(String[] args) { mythread my1 = new mythread("zzzzz"); mythread my2 = new mythread("阿萨"); mythread my3 = new mythread("aaaaaa"); Thread.currentThread().setName("pppp"); my1.setDaemon(true); my2.setDaemon(true); my3.setDaemon(true); my1.start(); my2.start(); my3.start(); for (int i=0;i<10;i++){ System.out.println(Thread.currentThread().getName()+":"+i); }
1.6 线程生命周期
1.7 多线程实现方式
方式二:实现Runnable接口方式二更常用
定义一个类MyRunnable实现Runnable接口
在MyRunnable类中重写run()方法
创建MyRunnable类的对象
床架Thread类的对象,把MyRunnable对象作为构造方法的参数
启动线程
多线程的实现方案:
继承Thread类
实现Runnable接口
相比继承Thread类,实现Runnable接口的好处。
避免了java单继承的局限性
适合多个相同程序的代码去处理同一个资源的情况,把线程和程序的代码、数据有效分离,较好的体现了面向对象的设计思想。
2、线程同步
2.1 案例:卖票
需求:电影院卖票,共有100个票,三个窗口卖票,请设计一个程序模拟该电影院卖票。
public class demo { public static void main(String[] args) { sellticket s = new sellticket(); Thread t1 = new Thread(s); Thread t2 = new Thread(s); Thread t3 = new Thread(s); t1.setName("窗口一"); t2.setName("窗口二"); t3.setName("窗口三"); t1.start(); t2.start(); t3.start(); } }
public class sellticket implements Runnable { private int tickets = 100; @Override public void run() { while (true) { if (tickets > 0) { System.out.println( Thread.currentThread().getName() + "卖第" + tickets + "张票"); tickets--; } } } }
思考:
出票要有时间延迟的
while (true) { if (tickets > 0) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println( Thread.currentThread().getName() + "卖第" + tickets + "张票"); tickets--; } }
2.1.1 卖票案例数据安全问题的解决
为什么出现问题?
是否是多线程环境
是否由共享环境
是否由多条语句操作共享数据
如何解决呢?
基本思想:让程序没有安全问题的环境
怎么实现呢?
同步代码块
锁多条语句操作共享数据,可以同步代码块实现
格式:
synchronized(任意对象){
多条语句操作共享数据的代码
}
synchronized(任意对象):就相当于给代码加锁了,任意对象就可以看成是一把锁。
private Object obj = new Object();
synchronized (obj) {。。。。}
同步的好处:
好处:解决了多线程的数据安全问题
弊端:当线程很多的时候,因为每个线程都会区判断同步上的锁,这是很耗费资源的,无形中会减低程序的运行效率
public class sellticket implements Runnable { private int tickets = 100; private Object obj = new Object(); @Override public void run() { while (true) { synchronized (obj) { if (tickets > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "卖第" + tickets + "张票"); tickets--; } } } } }
2.2 同步方法
同步方法:就是把synchronized关键字加到方法上
格式:
修饰符synchronized返回值类型 方法名(方法参数){ }
同步方法的锁对象:this
同步静态方法:就是把synchronized关键字加到静态方法上面
格式:
修饰符static synchronized 返回值类型 方法名 (方法参数){ }
同步静态方法的锁对象是什么呢?
类名.class
public class sellticket implements Runnable { private static int tickets = 100; private Object obj = new Object(); int x = 0; @Override public void run() { while (true) { if (x % 2 == 0) { //换成了this,与下面那个方法上面的锁一样,this是非静态的锁的对象。 // synchronized (this) { //静态同步方法的锁类名.class synchronized (sellticket.class) { if (tickets > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "卖第" + tickets + "张票"); tickets--; } } } else { sell(); } } } // private void sell() { // synchronized (obj) { // if (tickets > 0) { // try { // Thread.sleep(100); // } catch (InterruptedException e) { // e.printStackTrace(); // } // System.out.println(Thread.currentThread().getName() + "卖第" + tickets + "张票"); // tickets--; // } // } // } //方法上面有锁 // private synchronized void sell() { // if (tickets > 0) { // try { // Thread.sleep(100); // } catch (InterruptedException e) { // e.printStackTrace(); // } // System.out.println(Thread.currentThread().getName() + "卖第" + tickets + "张票"); // tickets--; // } // } //变成静态得了,给静态方法加锁 private static synchronized void sell() { if (tickets > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "卖第" + tickets + "张票"); tickets--; } } }
public class demo { public static void main(String[] args) { sellticket s = new sellticket(); Thread t1 = new Thread(s); Thread t2 = new Thread(s); Thread t3 = new Thread(s); t1.setName("窗口一"); t2.setName("窗口二"); t3.setName("窗口三"); t1.start(); t2.start(); t3.start(); } }
2.3 线程安全的类
StringBuffer:线程安全,可变的字符序列。
从版本JDK5开始,被StringBuilder替代,通常应该使用StringBUilder类,因为它支持所有相同的操作,但它更快,因为它不执行同步。
Vector:
从java平台v1.2开始,该类改进了List接口,使其称为Java Collections Framework的成员。与新的集合实习那不同,Vector被同步。如果不需要线程安全的实现,建议使用ArrayList代替Vector。
Hashtable:
该类实现了一个哈希表,它将键映射到值,任何非null对象都可以用作键或者值。
凑够java2平台开始,该类进行了该技能,实现了MAp接口,使其成为JAva CollectionsFramework的成员,与新的集合实现不同,hashtable被同步,如果不需要线程安全的实现,建议使用hashmap代替hashtable。
2.4 lock锁
为了清晰的表达如何加锁和放锁。
所以有lock
lock是西安提供比使用synchronized方法和语句可以获得更广泛的锁定操作
lock中提供了获得锁和释放锁的方法
void lock():获得锁
void unlock():释放锁
lock是接口不能直接实例化,这里采用它的实现类Reentrantlock来实例化
Reentrantlock的构造方法:
ReentrantLock():创建一个ReentrantLock的实例。
private Lock lock = new ReentrantLock();
lock.lock();
lock.unlock();用try。。。。catch。。。。
public class sellticket implements Runnable { private static int tickets = 100; private Lock lock = new ReentrantLock(); @Override public void run() { while (true) { lock.lock(); try{ if (tickets > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "卖第" + tickets + "张票"); tickets--; } }finally{ lock.unlock(); } } } }
3、生产者消费者
生产者消费者模式是一个十分经典的多线程写作的模式,弄懂生产者消费者问题能够让我们对多线程变成的理解更加深刻,所谓生产者消费这问题,实际上主要是包含了两类线程:
一类是生产者线程主要用于生产数据
一类是消费这线程主要用于消费数据
为了解耦生产者消费者之间的关系,通常采用共享的数据区域,就像是一个仓库
生产者生产数据之后直接放置在共享数据中,并不需要关心生产者的行为。
为了体现生产和消费过程中的等待和唤醒,java就提供了几个方法:
在Object()类中:
void wait():导致当前线程等待,知道另一个线程调用该对象的notify()方法或者notifyAll()方法。
void notify():唤醒正在等待对象监视器的单个线程
void notifyAll():唤醒整下等待对象监视器的所有线程
案例:
奶箱类:定义个成员变量
生产者类
消费这类
测试类
public class box { private int milk; private boolean state = false; public synchronized void put(int milk){ if(state){ try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } this.milk = milk; System.out.println("送奶工"+this.milk+"瓶奶"); state = true; //唤醒其他等待的线程 notifyAll(); } public synchronized void get(){ if (!state){ try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("用户拿到"+this.milk+"瓶奶"); state = false; notifyAll(); } }
public class customer implements Runnable{ private box b; public customer(box b) { this.b = b; } @Override public void run() { while(true){ b.get(); } } }
public class producter implements Runnable{ private box b; public producter(box b) { this.b = b; } @Override public void run() { for (int i=1;i<=5;i++){ b.put(i); } } }
public class demo { public static void main(String[] args) { box b =new box(); producter p = new producter(b); customer c = new customer(b); Thread t1 = new Thread(p); Thread t2 = new Thread(c); t1.start(); t2.start(); } }