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());
}
}
1444
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
