根据blibli狂神说java以及
https://www.cnblogs.com/jiawen010/p/11855768.html编写
1.重写Thread类的run()方法
2.实现Runable接口的rum方法,再Thread(runable)
package 静态代理;
public class Demo {
public static void main(String[] args) {
WeddingCompany weddingCompany=new WeddingCompany(new You());
weddingCompany.HappyMerry();
}
interface Merry{
void HappyMerry();
}
//真实对象
static class You implements Merry{
@Override
public void HappyMerry() {
System.out.println("章老师要结婚了,超开心");
}
}
//代理对象(帮助你结婚)
static class WeddingCompany implements Merry{
private You you;
WeddingCompany(You you){
this.you=you;
}
@Override
public void HappyMerry() {
before();
you.HappyMerry();
after();
}
private void after() {
System.out.println("婚前现场布置...");
}
private void before() {
System.out.println("婚后结尾款...");
}
}
}
volatile只能修饰变量,保证的变量的可见性,有序性,无法保证原子性。如果一个共享变量被volatile关键字修饰,那么如果一个线程修改了这个共享变量后,其他线程是立马可知的。但是无法保证原子性
详情请看:
https://www.cnblogs.com/xd502djj/p/9873067.html
synchronized可以用在变量、方法、类、同步代码块等,用于锁住资源,其他线程要是想调用该资源,需要等待。重量级操作,效率较低
Lock是一个接口,ReentrantLock是它的实现类,调用lock.lock()锁住资源,lock.unlock()解锁资源,效率较高
sleep让线程休眠,但是资源还是锁住的,它是Thread的静态方法
wait()用于线程间通信,是Object里的静态方法,使用后会释放资源,是线程进入等待线程队列,当调用notify()/notifyall()时,才会从等待队列唤醒该线程。
join(),阻塞当前线程,加入另一个线程,知道另一个线程结束,才会启动阻塞的线程
yield(),线程礼让,该方法与sleep()类似,只是不能由用户指定暂停多长时间。不会释放锁。
当出现A要生产,B要消费。他们有一个共享资源区,如果都占用该资源区就会出现死锁,这个时候可以使用wait()方法,具体是在生产完以后使用wait()释放资源,然后消费完以后,调用notify()。
1.创建/销毁线程伴随着系统开销,过于频繁的创建/销毁线程,会很大程度上影响处理效率
2.线程能共享系统资源,如果同时执行的线程过多,就有可能导致系统资源不足而产生阻塞
3.对线程进行一些简单的管理
比如:延时执行、定时循环执行的策略等
//创建线程池
ExecutorService service= Executors.newFixedThreadPool(10);
源码
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
corePoolSize:最小活动线程数量
maximumPoolSize:最大线程数量
workQueue:该线程池中的任务队列:维护着等待执行的 Runnable 对象。当所有的核心线程都在干活时,新添加的任务会被添加到这个队列中等待处理,如果队列满了,则新建非核心线程执行任务
1.newCachedThreadPool
可缓存线程池,先查看池中有没有以前建立的线程,如果有,就直接使用。如果没有,就建一个新的线程加入池中,缓存型池子通常用于执行一些生存期很短的异步型任务
package 线程池;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 描述: 创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程,那么就会回收部分空闲(60秒不执行任务)的线程,当任务数增加时,此线程池又可以智能的添加新线程来处理任务。
* 此线程池不会对线程池大小做限制,线程池大小完全依赖于操作系统(或者说JVM)能够创建的最大线程大小。
**/
public class TestNewCachedThreadPool {
public static void main(String[] args) {
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 1; i <= 10; i++) {
final int index = i;
try {
Thread.sleep(index * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
cachedThreadPool.execute(new Runnable() {
@Override
public void run() {
String threadName = Thread.currentThread().getName();
System.out.println("执行:" + index + ",线程名称:" + threadName);
}
});
}
}
}
2.newFixedThreadPool
创建一个可重用固定个数的线程池,以共享的无界队列方式来运行这些线程。
package 线程池;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class NewFixedThreadPoolTest {
public static void main(String[] args) {
// 创建一个可重用固定个数的线程池
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
fixedThreadPool.execute(new Runnable() {
public void run() {
try {
// 打印正在执行的缓存线程信息
System.out.println(Thread.currentThread().getName()
+ "正在被执行");
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
}
3.newScheduledThreadPool
创建一个定长线程池,支持定时及周期性任务执行
package 线程池;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class NewScheduledThreadPoolTest {
public static void main(String[] args) {
//创建一个定长线程池,支持定时及周期性任务执行——延迟执行
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
//延迟1秒执行
/*scheduledThreadPool.schedule(new Runnable() {
public void run() {
System.out.println("延迟1秒执行");
}
}, 1, TimeUnit.SECONDS);*/
//延迟1秒后每3秒执行一次
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
public void run() {
System.out.println("延迟1秒后每3秒执行一次");
}
}, 1, 3, TimeUnit.SECONDS);
}
}
4.newSingleThreadExecutor
创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
package 线程池;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class NewSingleThreadExecutorTest {
public static void main(String[] args) {
//创建一个单线程化的线程池
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {
public void run() {
try {
//结果依次输出,相当于顺序执行各个任务
System.out.println(Thread.currentThread().getName()+"正在被执行,打印的值是:"+index);
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
}