1、Thread和Runnable的区别:
如果是一个类继承Thread,则不适合资源共享。但是如果实现了Runnable接口的话,则很容易的实现资源共享
【总结】
实现runnable接口比继承Thread类所具有的优势:
a、适合多个相同的程序代码的线程去共享同一个资源
b、可以避免java中的单继承的局限性
c、增加程序的健壮性,降级解耦操作,代码可以被多个线程共享,代码和线程独立。
d、线程池只能放入实现runnbale或callable类线程,不能直接放入继承Thread类。
【扩充】在java中,每次程序运行至少启动两个线程。一个是main线程,一个是垃圾收集线程。因为每当使用java命令执行一个类的时候,实际上都会启动一个jvm,每个jvm其实就是在操作系统中启动了一个进程。
3、匿名内部类方式实现线程的创建
匿名:没有名字
内部类:写在其他类内部的类
匿名内部类的作用:简化代码
把子类继承父类,重写父类方法,创建子类对象合一步完成
把实现类实现类接口,重写接口中的方法,创建实现类对象合成一步完成
匿名内部类的最终产物:子类/实现类对象,而这个类没有名字
格式:
new 父类/接口(){
重复父类/接口中的方法
}
2、synchronized修饰代码块
public void run() {
while (true) {
synchronized (BBB.class) {
if (ticket > 0) {
try {
Thread.sleep(100L);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "当前正在卖第:" + ticket + " 张票");
ticket--;
}
}
}
}
public static void main(String[] args) {
BBB bbb = new BBB();
new Thread(bbb).start();
new Thread(bbb).start();
new Thread(bbb).start();
}
new Thread().start()就是在java内存中开辟一块新的栈空间,然后执行run方法,然后在新开辟的栈中执行方法体。
2、解决线程安全的第二种方案:使用同步方法
使用步骤:
1、把访问了共享数据代码抽取出来,放到一个方法中。
2、在方法上添加synchronized修饰符
class BBB implements Runnable {
private static int ticket = 100;
@Override
public void run() {
System.out.println("this "+this);
while (true) {
synchronized (this) {
payTicket();
}
}
}
public void payTicket(){
synchronized(this){
if (ticket > 0) {
try {
Thread.sleep(100L);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "当前正在卖第:" + ticket + " 张票");
ticket--;
}
}
}
}
public static void main(String[] args) {
BBB bbb = new BBB();
System.out.println("this--->"+ bbb);
new Thread(bbb).start();
new Thread(bbb).start();
new Thread(bbb).start();
}
静态同步方法:
public static synchronized void payTicket() {
if (ticket > 0) {
try {
Thread.sleep(100L);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "当前正在卖第:" + ticket + " 张票");
ticket--;
}
}
静态的同步方法
锁对象是谁?
不能是this,this是创建对象之后产生的,静态方法优先于对象,静态方法的锁对象是本类的class属性 --》class文件对象
4、lock锁:
解决线程安全问题的第三种方案:使用lock锁
lock实现提供了比使用synchronized方法合语句可获得更广泛的锁定操作。
lock接口中的方法:
void lock() 获取锁
void unlock() 释放锁
使用步骤:
a、在成员位置创建一个ReentrantLock对象
b、在肯能会出现安全问题的代码前调用lock接口中的方法获取锁
c、在可能会出现安全问题的代码后调用lock接口中的unlock释放锁
private static int ticket = 100;
Lock lock = new ReentrantLock();
@Override
public void run() {
System.out.println("this " + this);
while (true) {
lock.lock(); //获取锁
if (ticket > 0) {
try {
System.out.println(Thread.currentThread().getName() + "当前正在卖第:" + ticket + " 张票");
ticket--;
Thread.sleep(100L);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();//释放锁
}
}
}
}
5、线程的状态:
6、wait和notify
public static void main(String[] args) {
Object obj = new Object();
new Thread() {
@Override
public void run() {
while (true){
synchronized (obj) {
System.out.println("告诉老板要的包子种类合数量");
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}.start();
new Thread() {
@Override
public void run() {
while (true){
try {
//睡眠5秒,表示正在做包子
Thread.sleep(5000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (obj) {
System.out.println("包子已经做好");
obj.notify();
System.out.println("呼喊顾客,进行吃包子");
System.out.println("----------------------");
}
}
}
}.start();
}
【注意】
顾客和老板线程必须使用同步代码块,保证等待和唤醒只有一个在执行。
同步使用的锁对象必须保证唯一
只有锁对象才能调用wait和notify方法。
Object类中的方法:
void wait()
在其他线程调用次对象的notify()方法或notifyAll()方法前,导致当前线程等待。
void notify()
唤醒在此对象监视器上等待的单个线程
会继续执行wait方法之后的代码
7、等待与唤醒机制
线程见通信:多个线程在处理同一个资源,但是处理的动作(线程任务)却不同
【比如】:线程A用来生成包子的,线程B用来吃包子的,包子可以理解为同一资源,线程A与线程B处理的动作,一个是生产,一个是消费,那么线程A与线程B之间就存在线程通信问题。
为什么要处理线程间通信:
多个线程并发执行时,在默认情况下cpu是随机切换线程的,当我们需要多个线程来共同完成一件任务,并且我们希望他们有规律的执行,那么线程之间需要一些协调通信 ,以此来帮助我们达到多线程共同操作一份数据。
如何保证线程间通信有效利用资源:
多个线程在处理同一个资源,并且任务不同时,需要线程间通信来帮助解决线程之间对同一个变量的使用或操作。就是多个线程在操作同一份数据时,避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即 —— 等待唤醒机制
等待唤醒机制:
什么使等待唤醒机制:
这使多个线程间的一种协作机制。谈到线程我们经常想到的使线程间的竞争(race),比如去争夺锁,但这并不是故事的全部,线程间也会有协作机制。就好比在公司里你和你们的同事们,你们可能存在晋升时的竞争,但更多时候你们更多是一起合作以完成某些任务。
wait/notify 就是线程间的一种协作机制
【注意】:哪怕只通知了一个等待的线程,被通知的线程也不可能立即恢复执行,因为它当初中断的地方是在同步块内,而此刻它已经不持有锁了,所以她需要再次尝试获取锁(很有可能面临其他线程的竞争),成功后才能在当初调用wait方法之后的地方恢复执行。
总结如下:
a、如果能获取锁,线程就从wating状态变成runnable状态;
b、否则,从wait set出来,又进入entry set,线程就从waiting 状态变成blocked状态。
调用wait和notify方法需要注意的细节:
a、wait方法与notify方法必须要有同一个锁对象调用。因为:对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
b、wait方法与notify方法是属于object类的方法。因为:锁对象可以是任意对象,而任意对象的所属类都是继承了object类的。
c、wait方法与notify方法必须要在同步代码块或者同步函数中使用。因为:必须要通过锁对象调用这两个方法。
【小案例】
public class ProuuctBaozi extends Thread {
private int count = 0;
private BaoZi baoZi;
public ProuuctBaozi(BaoZi baoZi) {
this.baoZi = baoZi;
}
ExecutorService executorService = Executors.newFixedThreadPool(10);
@Override
public void run() {
while (true) {
synchronized (baoZi) {
if (baoZi.getFlag() == true) {
try {
baoZi.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
if (count % 2 == 0) {
baoZi.setPi("薄皮");
baoZi.setXian("牛肉");
} else {
baoZi.setPi("厚皮");
baoZi.setXian("韭菜猪肉");
}
count++;
System.out.println("正在生产" + baoZi.getPi() + baoZi.getXian());
try {
Thread.sleep(3000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
baoZi.setFlag(true);
System.out.println("包子好了" + baoZi.getPi() + baoZi.getXian());
baoZi.notify();
}
}
}
}
}
public class ConsumerBaoZi extends Thread{
BaoZi baoZi;
public ConsumerBaoZi(BaoZi baoZi){
this.baoZi= baoZi;
}
@Override
public void run() {
while (true){
synchronized (baoZi){
if(baoZi.getFlag() == false){
try {
baoZi.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else {
baoZi.notify();
System.out.println("有包子,吃货正在吃包子正在吃"+ baoZi.getPi()+baoZi.getXian());
System.out.println( baoZi.getPi()+baoZi.getXian()+"被吃货吃完了");
baoZi.setFlag(false);
System.out.println("--------------------");
}
}
}
}
}
public class TestPC {
public static void main(String[] args) {
BaoZi baoZi = new BaoZi();
new ProuuctBaozi(baoZi).start();
new ConsumerBaoZi(baoZi).start();
}
}
8、线程池
线程池容器-》集合(ArrayList,HashSet,LinkeList,HashMap)
当程序第一次启动的时候,创建多个线程,保存到一个集合当中,当我们需要的时候,就可以从集合中取出来线程使用
Thread t = list.remove(0); //返回的是被移除的元素(线程只能被一个任务使用)
Thread t = linked.e=removeFirst();
当我们使用完毕线程,需要把线程归还给线程池;
list.add(t);
linked.addLast(t);
合理利用线程池的好处:
a、降低资源消耗,减少了创建和销毁线程的次数,每个工作线程都可以被重复利用,可以执行多个任务
b、提高响应速度。当任务到达的时候,任务可以不需要等待线程创建就能立即执行
c、提高线程的可管理性。可以根据系统的承受能力,调整线程池中工作线程的数目,防止因为消耗过多的内存,而把服务器累趴下(每个线程需要大约1MB内存,线程开的越多,消耗的内存越大,最后死机)
创建线程池的方法:
线程池是java1.5之后提供的
java.util.concurrent.Executors:线程池的工厂类,用来生成线程池
Executors类中的静态方法:
参数:int nThreads:创建线程池中包含的线程数量
返回值:
ExecutorService接口:返回的是ExecutorService接口实现类对象,我们可以使用ExecutorService接口接收(面向对象变成)
用来从线程池中获取线程,调用start方法,执行线程任务
submit(Runnable task) 提交一个Runnable任务用于执行
关闭/销毁线程池的方法
void shutdown()
线程池的使用步骤:
a、使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
b、创建一个类,实现runnable接口,重写run方法,设置线程任务
c、调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法
d、调用ExecutorService中的方法shutdown销毁线程池(不建议执行)
创建线程的方式:
1、继承Thread类,重写run方法
2、实现runnable接口,重写run方法
3、通过线程池创建
4、实现Callable接口,重写call方法,然后结合FutureTask使用。
public class MyThread implements Callable<String> {
@Override
public String call() throws Exception {
System.out.println(Thread.currentThread().getName() + "正在运行");
return "call方法执行完毕";
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask<String> futureTask = new FutureTask<>(new MyThread());
Thread thread3 = new Thread(futureTask);
thread3.start();
System.out.println(Thread.currentThread().getName() + futureTask.get());
}
}