静态代理
举例：
- 人：真实的角色
- 公司：代理你，帮忙处理关于某件事
- 某件事：公司提供一个接口，然后做这个事
//代理对象可以做真实对象做不了的事，真实对象可以只做自己的事
public class StaticProxy {
public static void main(String[] args) {
You you = new You();//真实对象
new Thread(()->System.out.println("love")).start();//Thread代表Company，（）内真实对象
// Campany campany = new Campany(new You());
// campany.Marry01();
new Campany(new You()).Marry01();//一句代替上面两句
}
}
interface Marry{
void Marry01();
}
//真实角色，去结婚
class You implements Marry{
@Override
public void Marry01() {
System.out.println("这件事");
}
}
//代理角色，帮助
class Campany implements Marry{
private Marry target;
public Campany(Marry target) {
this.target = target;
}
@Override
public void Marry01() {
before();
this.target.Marry01();
after();
}
private void after() {
System.out.println("收钱");
}
private void before() {
System.out.println("布置");
}
}
Lamda表达式
- 入希腊字母表中排序第十一位的字母，英语名称为Lambda
- 避免匿名内部类定义过多
- 其实质属于函数式编程的概念
new Thread(()->System.out.println("love")).start();//Thread代表Company，（）内真实对象
-
为什么要使用lambda表达式
- 避免匿名内部类定义过多
- 可以让你的代码看起来很简洁
- 去掉了一堆没有意义的代码，只留下核心的逻辑。
-
理解Functional lnterface(函数式接口）是学习Java8 lambda表达式的关键所在。
-
函数式接口的定义:
-
任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。
public interface Runnable { public abstract void run(); } -
对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。
-
//这是一个简化过程（狂神这里讲的好好，我晤了多线程10分p）后面还有讲带参哒
public class TestLamda {
//3.静态内部类
static class Like2 implements Ilike{
@Override
public void lamda() {
System.out.println("2");
}
}
public static void main(String[] args) {
Ilike ilike = new Like();
ilike.lamda();
ilike=new Like2();
ilike.lamda();
//4.局部内部类
class Like3 implements Ilike{
@Override
public void lamda() {
System.out.println("3");
}
}
ilike=new Like3();
ilike.lamda();
//匿名内部类
ilike =new Ilike() {
@Override
public void lamda() {
System.out.println("4");
}
};
ilike.lamda();
//6.用lamda简化
ilike=()->{
System.out.println("5");
};
ilike.lamda();
}
}
//1.定义一个接口
interface Ilike{
void lamda();
}
//2.实现类
class Like implements Ilike{
@Override
public void lamda() {
System.out.println("1");
}
}
总结:
- lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹。
- 前提是接口为函数式接口
- 多个参数也可以去掉参数类型，要去掉就都去掉
线程的五大状态
停止线程
-
不推荐使用JDK提供的stop()、destroy()方法。【已废弃】
-
推荐线程自己停止下来
-
建议使用一个标志位进行终止变量当flag=false，则终止线程运行。
-
测试stop
- 建议线程正常停止—>利用次数,不建议死循环。
- 建议使用标志位—>设置一个标志位
- 不要使用stop或者destroy等过时或者JDK不建议使用的方法
public class TestStop implements Runnable{
//1.设置一个标识位
private boolean flag =true;
@Override
public void run() {
int i=0;
while (flag){
System.out.println("run...Thread" + i++);
}
}
//2.设置一个公开的方法停止线程，转换标识符
public void stop(){
this.flag=false;
}
public static void main(String[] args) {
TestStop testStop = new TestStop();
new Thread(testStop).start();
for (int i=0;i<1000;i++){
System.out.println("main" + i);
if (i==900){
testStop.stop();
System.out.println("停止");
}
}
}
}
线程休眠
- sleep(时间)指定当前线程阻塞的毫秒数;
- sleep存在异常InterruptedException;
- sleep时间达到后线程进入就绪状态;
- sleep可以模拟网络延时，倒计时等。
- 每一个对象都有一个锁,sleep不会释放锁;
public class TestSleep02 {
public static void main(String[] args) {
// //打印当前时间
// Date time=new Date(System.currentTimeMillis());//获取当前时间
// while (true){
// try {
// Thread.sleep(1000);
// System.out.println(new SimpleDateFormat("HH:mm:ss").format(time));
// time=new Date(System.currentTimeMillis());//更新时间
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
//
// }
try {
tenDown();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void tenDown() throws Exception{
int num=10;
while (true){
Thread.sleep(1000);
System.out.println(num--);
if (num<=0){
break;
}
}
}
}
未去掉的是倒计时，去掉的是打印当前时间的倒计时
线程礼让（Yield）
-
礼让线程，让当前正在执行的线程暂停，但不阻塞
-
将线程从运行状态转为就绪状态
-
让cpu重新调度，礼让不一定成功!看CPU心情
-
礼让不一定成功
public class TestYield {
public static void main(String[] args) {
MyYield myYield = new MyYield();
new Thread(myYield,"a").start();
new Thread(myYield,"b").start();
new Thread(myYield,"c").start();
}
}
class MyYield implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程开始");
Thread.yield();
System.out.println(Thread.currentThread().getName()+"线程结束");
}
}
Join
- Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
- 可以想象成插队
public class TestJoin implements Runnable{
@Override
public void run() {
for (int i=0;i<100;i++){
System.out.println("VIP" + i);
}
}
public static void main(String[] args) throws Exception {
TestJoin testJoin = new TestJoin();
Thread thread = new Thread(testJoin);
thread.start();
//主线程
for (int i = 0;i<300;i++){
if(i==200) {
thread.join();//插队
}
System.out.println("main" + i);
}
}
}
线程观察状态
- Thread.State
线程状态。线程可以处于以下状态之一讼- NEw
尚未启动的线程处于此状态。 - RUNNABLE
在Java虚拟机中执行的线程处于此状态。 - BLOCKED
被阻塞等待监视器锁定的线程处于此状态。 - WAITING
正在等待另一个线程执行特定动作的线程处于此状态。 - TIMED_WAITING
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。 - TERMINATED
已退出的线程处于此状态。
- NEw
一个线程可以在给定时间点处干一个状态。这些状态是不反映任何操作系统线程状态的虎拟机状态。
public class TestState {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(()->{
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("//");
});
//观察状态
Thread.State state = thread.getState();
System.out.println(state);
//观察启动后
thread.start();//启动线程
state = thread.getState();
System.out.println(state);//Run
while (state != Thread.State.TERMINATED){//只要线程不终止，就一直输出状态
Thread.sleep(100);
state = thread.getState();//更新线程状态
System.out.println(state);//输出状态
}
}
}
线程的优先级
-
Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。
-
线程的优先级用数字表示，范围从1~10.
- Thread.MIN_PRIORITY = 1;
- Thread.MAX_PRIORITY = 10;
- Thread.NORM_PRIORITY = 5;
-
使用以下方式改变或获取优先级
getPriority() . setPriority(int xxx)
public class MyThread1 extends Thread {
@Override
public void run() {
System.out.println("MyThread1 run priority=" + this.getPriority());
MyThread2 thread2 = new MyThread2();
thread2.start();
}
}
public class MyThread2 extends Thread {
@Override
public void run() {
System.out.println("MyThread2 run priority=" + this.getPriority());
}
}
public static void main(String[] args) {
System.out.println("main thread begin priority="
+ Thread.currentThread().getPriority());
Thread.currentThread().setPriority(6);
System.out.println("main thread end priority="
+ Thread.currentThread().getPriority());
MyThread1 thread1 = new MyThread1();
thread1.start();
}
优先级低只是意味着获得调度的概率低.并不是优先级低就不会被调用了.这都是看CPU的调度
守护（saemon）线程
- 线程分为用户线程和守护线程
- 虚拟机必须确保用户线程执行完
- 毕虚拟机不用等待守护线程执行完毕
- 如,后台记录操作日志,监控内存,垃圾回收等待…
read.currentThread().setPriority(6);
System.out.println("main thread end priority="
+ Thread.currentThread().getPriority());
MyThread1 thread1 = new MyThread1();
thread1.start();
}
**优先级低只是意味着获得调度的概率低.并不是优先级低就不会被调用了.这都是看CPU的调度**
### 守护（saemon）线程
- 线程分为**用户线程**和**守护线程**
- 虚拟机必须确保用户线程执行完
- 毕虚拟机不用等待守护线程执行完毕
- 如,后台记录操作日志,监控内存,垃圾回收等待..
2882
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
