/**
-
@author by 闲言
-
@classname StactProxy
-
@description 静态代理简单说明
-
@date 2021/7/29 12:19
*/
public class StacticProxy {
public static void main(String[] args) {
You you = new You();//你要结婚
new Thread( () -> System.out.println(“嘤嘤嘤”)).start();
new WeddingCompany(new You()).hashCode();
}
}
interface Marry {
void HappyMarry();
}
//真实角色,你去结婚
class You implements Marry {
@Override
public void HappyMarry() {
System.out.println(“闲言要结婚了,超开心”);
}
}
//真实角色,帮助你结婚
class WeddingCompany implements Marry {
//代理谁–》真实目标角色
private Marry target;
public WeddingCompany(Marry target) {
this.target = target;
}
@Override
public void HappyMarry() {
before();
this.target.HappyMarry();//这就是真实对象
after();
}
private void after() {
System.out.println(“结婚之后,收尾款”);
}
private void before() {
System.out.println(“结婚之前,布置现场”);
}
}
入 希腊字母表中排序第十一位的字母,英语名称为Lambda
避免内部类定义过多
其实质属于函数式编程概念
(params) -> expression [表达式]
(params) -> statement [语句]
(params) -> {statement }
new Thread(()-> System.out.println(“多线程学习”)).start();
为什么要使用lambda 表达式
1.避免你们内部类定义过多
2.可以让你的代码看起来很简洁
3.去掉了一堆没有意义的代码,只留下核心的逻辑
函数式接口的定义
1.任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口。
2.对于函数式接口,我们可以通过lambda 表达式来创建该接口的对象。
public interface Runnable{
public abstract void run();
}
案例1
package cn.bloghut.lambda;
/**
-
@author by 闲言
-
@classname Testlambda
-
@description 推导lambda表达式
-
@date 2021/7/29 12:38
*/
public class Testlambda {
//3.静态内部类
static class Like2 implements ILike {
@Override
public void lambda() {
System.out.println(" i like lambda2");
}
}
public static void main(String[] args) {
ILike like = new Like();
like.lambda();
like = new Like2();
like.lambda();
//4.局部内部类
class Like3 implements ILike {
@Override
public void lambda() {
System.out.println(" i like lambda3");
}
}
like = new Like3();
like.lambda();
//5.匿名内部类
like = new ILike() {
@Override
public void lambda() {
System.out.println(" i like lambda4");
}
};
like.lambda();
//6.用lambda表达式
like = ()->{
System.out.println(" i like lambda5");
};
like.lambda();
}
}
//1.定义一个函数式接口
interface ILike {
void lambda();
}
//2.实现类
class Like implements ILike {
@Override
public void lambda() {
System.out.println(" i like lambda");
}
}
线程方法
线程停止
1.建议线程正常停止----》利用次数。不建议死循环
2.建议使用标志位----》设置一个标志位
3.不用使用stop或destory 等过时或者JDK 不建议使用的方法
package cn.bloghut.state;
/**
-
@author by 闲言
-
@classname TestStop
-
@description 测试stop
-
@date 2021/7/29 17:51
*/
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) {
//调用stop方法切换标志位,让线程停止
testStop.stop();
System.out.println(“该线程停止了”);
}
}
}
}
1.sleep(时间)指定当前线程阻塞的毫秒数;
2.sleep 存在异常InterruptedException;
3.sleep 时间达到后线程进入就绪状态
4.sleep 可以模拟网络延时,倒计时等。
5.每一个对象都有一个锁,sleep不会释放锁;
package cn.bloghut.state;
/**
-
@author by 闲言
-
@classname TestSleep
-
@description 模拟网络延时:放大问题的发生性
-
@date 2021/7/29 18:09
*/
public class TestSleep implements Runnable {
//票数
private int ticketNums = 10;
@Override
public void run() {
while (true) {
if (ticketNums <= 0) {
break;
}
//模拟延时
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + “—>拿到了第” + ticketNums-- + “票”);
}
}
public static void main(String[] args) {
TestSleep testSleep = new TestSleep();
new Thread(testSleep,“小明”).start();
new Thread(testSleep,“小红”).start();
new Thread(testSleep,“小黄牛”).start();
}
}
案例:模拟倒计时 、打印当前系统时间
package cn.bloghut.state;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
-
@author by 闲言
-
@classname TestSleep2
-
@description 模拟倒计时
-
@date 2021/7/29 18:23
*/
public class TestSleep2 {
/**
-
模拟倒计时
-
@throws InterruptedException
*/
public static void testDown() throws InterruptedException {
int num = 10;
while (true) {
Thread.sleep(1000);
System.out.println(num–);
if (num == 0) {
break;
}
}
}
/**
- 打印当前时间
*/
public static void printNowDate() {
//打印当前系统时间
Date stattTime = new Date(System.currentTimeMillis());
while (true) {
try {
//休眠1秒
Thread.sleep(1000);
//格式化时间,并输出时间
System.out.println(new SimpleDateFormat(“yyyy年MM月dd日 HH:mm:ss”).format(stattTime));
//更新获取时间
stattTime = new Date(System.currentTimeMillis());
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
printNowDate();
}
}
1.礼让线程,让当前正在执行的线程暂停,但不阻塞
2.将线程从运行状态转为就绪状态
3.让cpu 重新调度,礼让不一定成功!看cpu心情
package cn.bloghut.state;
/**
-
@author by 闲言
-
@classname TestYied
-
@description 测试礼让线程
-
礼让不一样成功,看CPU心情
-
@date 2021/7/29 18:35
*/
public class TestYield {
public static void main(String[] args) {
MyYield myYield = new MyYield();
new Thread(myYield,“A”).start();
new Thread(myYield,“B”).start();
}
}
class MyYield implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+“线程开始执行”);
Thread.yield();//礼让
System.out.println(Thread.currentThread().getName()+“线程停止执行”);
}
}
Join 合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞
可以想象成插队
练习:
package cn.bloghut.state;
/**
-
@author by 闲言
-
@classname TestJoin
-
@description 测试join 方法
-
想象为插队
-
@date 2021/7/29 18:42
*/
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 InterruptedException {
TestJoin testJoin = new TestJoin();
Thread thread = new Thread(testJoin);
//启动线程
thread.start();
//主线程
for (int i = 0; i < 200; i++) {
if (i == 100) {
thread.join();//插队
}
System.out.println(“main” + i);
}
}
}
Thread.State
线程状态,线程可以处于以下状态之一:
NEW
尚未启动的线程处于此状态
RUNNABLE
在Java虚拟机中执行的线程处于此状态
BLOCKED
被阻塞等待监视器锁定的线程处于此状态
WAITING
正在等待另一个线程执行特定动作的线程处于此状态
TIMED WAITING
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
TERMINATED
已退出的线程处于此状态
一个线程可以在给定时间点处于一个状态,这些状态不反映任何操作系统线程状态的虚拟机状态。
package cn.bloghut.state;
/**
-
@author by 闲言
-
@classname TeestState
-
@description 观测线程状态
-
@date 2021/7/30 10:39
*/
public class TeestState {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(()->{
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
}catch (Exception e){
e.printStackTrace();
}
System.out.println(“/”);
}
});
//观察状态
Thread.State state = thread.getState();
System.out.println(state);
//观察启动后
thread.start();
state = thread.getState();
System.out.println(state);
//只要线程不终止,就一直输出状态
while (state != Thread.State.TERMINATED){
Thread.sleep(100);
state = thread.getState();//更新线程状态
System.out.println(state);//输出线程状态
}
}
}
注意:线程中断或结束,一旦进入死亡状态,就不能再次启动。
1.Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程,线程调度器安装优先级决定应该调度哪个线程来执行。
2.线程的优先级用数字表示,范围从1——10
Thread.MIN_PRIORITY = 1;
Thread.MAX_PRIORITY = 10;
Thread.NOPM_PRIORITY = 5;
使用以下方式改变或获取优先级
getPriority()
setPriority(int xx)
package cn.bloghut.state;
/**
-
@author by 闲言
-
@classname TestPriority
-
@description 测试线程的优先级
-
@date 2021/7/30 10:52
*/
public class TestPriority {
public static void main(String[] args) {
//主线程默认优先级
System.out.println(Thread.currentThread().getName()+“==”+Thread.currentThread().getPriority());
MyPriority myPriority = new MyPriority();
Thread t1 = new Thread(myPriority);
Thread t2 = new Thread(myPriority);
Thread t3 = new Thread(myPriority);
Thread t4 = new Thread(myPriority);
Thread t5 = new Thread(myPriority);
Thread t6 = new Thread(myPriority);
//先设置优先级,再启动
t1.start();
t2.setPriority(1);
t2.start();
t3.setPriority(4);
t3.start();
t4.setPriority(Thread.MAX_PRIORITY);//10
t4.start();
// t5.setPriority(-1);//通过查看源码发现,设置优先级为-1会报错(小于1)
// t5.start();
// t6.setPriority(11);//通过查看源码发现,设置优先级为11会报错(大于10)
//t6.start();
t5.setPriority(8);
t5.start();
t6.setPriority(7);
t6.start();
}
}
class MyPriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+“==”+Thread.currentThread().getPriority());
}
}
优先级低只是意味着获得调度的概率低,并不是优先级低就不会被调用,这都是看CPU的调度。
1.线程分为用户线程和守护线程
2.虚拟机必须确保用户线程执行完毕
3.虚拟机不用等待守护线程执行完毕
如:后台记录操作日志、监控内存、垃圾回收等等…
package cn.bloghut.state;
/**
-
@author by 闲言
-
@classname TestDaemon
-
@description 测试守护线程
-
@date 2021/7/30 12:14
*/
public class TestDaemon {
public static void main(String[] args) {
God god = new God();
You you = new You();
Thread thread = new Thread(god);
thread.setDaemon(true);//默认是false表示是用户线程,正常的线程都是用户线程
thread.start();//上帝守护线程启动
new Thread(you).start();//你 用户线程启动
}
}
//你
class You implements Runnable {
@Override
public void run() {
for (int i = 0; i < 36500; i++) {
System.out.println(“你一生都开心活着”);
}
System.out.println(“===goodbye! world=”);
}
}
//上帝
class God implements Runnable {
@Override
public void run() {
while (true) {
System.out.println(“上帝保护着你”);
}
}
}
线程同步
多个线程操作同一个资源
并发:同一个对象被多个线程同时操作
现实生活中,我们会遇到“同一资源,多个人都想使用”的问题,比如:食堂排队打饭,每个人都想吃饭,最天然的解决办法就是,排队。一个个来
处理多线程问题时,多个线程访问同一个对象(并发),并且某些线程还想修改这个对象,这个时候我们就需要线程同步,线程同步就是一种机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕,下一个线程再使用。
由于同一个进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入 锁机制 synchronized ,当一个线程获得对象的排它锁,独占资源,其他线程必须等待,使用后释放锁即可。
存在以下问题:
1.一个线程有锁会导致其他需要此锁的线程挂起;
2.在多线程竞争下,加锁,释放锁会导致比较多的上下文切换 和 调度延时,引起性能问题;
3.如果一个优先级高的线程等待一个优先级低的线程释放锁 会导致优先级倒置,引起性能问题。
线程不安全案例1:不安全的买票
package cn.bloghut.syn;
/**
-
@author by 闲言
-
@classname UnsafeBuyTicket
-
@description 不安全的卖票
-
@date 2021/7/30 17:21
*/
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket station = new BuyTicket();
new Thread(station,“闲言”).start();
new Thread(station,“鸡哥”).start();
new Thread(station,“黄牛”).start();
}
}
class BuyTicket implements Runnable {
//票
private int ticketNums = 10;
private boolean flag = true;//外部停止方式
@Override
public void run() {
//买票
while (flag) {
buy();
}
}
private void buy() {
//判断是否有票
if (ticketNums <= 0) {
flag = false;
return;
}
//模拟延时
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//买票
System.out.println(Thread.currentThread().getName() + “拿到” + ticketNums-- + “张票”);
}
}
线程不安全案例2:不安全的取钱
package cn.bloghut.syn;
/**
-
@author by 闲言
-
@classname UnsafeBank
-
@description 不安全的取钱
-
@date 2021/7/30 17:29
*/
public class UnsafeBank {
public static void main(String[] args) {
//账户
Account account = new Account(100, “结婚基金”);
Drawing you = new Drawing(account,50,“你”);
Drawing girlFriend = new Drawing(account,100,“girlFriend”);
you.start();
girlFriend.start();
}
}
//账户
class Account {
int money;//余额
String name;//卡名
public Account(int money, String name) {
this.money = money;
this.name = name;
}
}
//银行:模拟取款
class Drawing extends Thread {
Account account;//账户
//取了多少钱
int drawingMoney;
//现在手里有多少钱
int nowMoney;
public Drawing(Account account, int drawingMoney, String name) {
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
}
@Override
public void run() {
//判断有没有钱
if (account.money - drawingMoney < 0) {
System.out.println(Thread.currentThread().getName() + “钱不够,取不了”);
return;
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内余额 = 余额 减去 你取的前
account.money = account.money - drawingMoney;
//你手里的钱
nowMoney = nowMoney + drawingMoney;
System.out.println(account.name + “余额为:” + account.money);
//Thread.currentThread().getName() = this.getName();
System.out.println(this.getName() + “手里的钱” + nowMoney);
}
}
线程不安全案例3:不安全的集合
package cn.bloghut.syn;
import java.util.ArrayList;
import java.util.List;
/**
-
@author by 闲言
-
@classname UnsafeList
-
@description 线程不安全的集合
-
@date 2021/7/30 18:09
*/
public class UnsafeList {
public static void main(String[] args) throws InterruptedException {
List list = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
Thread.sleep(3000);
System.out.println(list.size());
}
}
同步方法
由于我们可以通过private 关键字来保证数据对象只能被方法访问,所以我们只需要对方法提出一套机制,这套机制就是synchronized 关键字,它包括两种用法:synchronized 方法和synchronized 块;
同步方法:public synchronized void method(int args){}
synchronized 方法 控制对 “ 对象”的访问,每个对象对应一把锁,每个synchronized 方法都必须获得调用该方法的对象的锁才能执行,否则线程会阻塞,方法一旦执行,就独占该锁,直到该方法返回才释放锁,后面被阻塞的线程才能获得这个锁,继续执行。
缺陷:若将一个大的方法声明为synchronized 将会影响效率。
方法里面需要修改的内容才需要锁,锁的太多,浪费资源。
同步块:synchronized (obj){ }
obj 称之为 同步监视器
obj 可以是任何对象,但是推荐使用共享资源作为同步监视器
同步方法中无需指定同步监视器,因为同步方法的同步监视器就是this,就是和这个对象本身,或者是class
同步监视器的执行过程
1.第一个线程访问,锁定同步监视器,执行其中代码
2.第二个线程访问,发现同步监视器,无法访问
3.第一个线程访问完毕,解锁同步监视器
4.第二个线程访问,发现同步监视器没有锁,然后锁定并访问
锁的对象就是变化的量,需要增删改的数据
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则几千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录大纲截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且后续会持续更新
如果你觉得这些内容对你有帮助,可以添加V获取:vip1024b (备注Java)
最后
无论是哪家公司,都很重视基础,大厂更加重视技术的深度和广度,面试是一个双向选择的过程,不要抱着畏惧的心态去面试,不利于自己的发挥。同时看中的应该不止薪资,还要看你是不是真的喜欢这家公司,是不是能真的得到锻炼。
针对以上面试技术点,我在这里也做一些分享,希望能更好的帮助到大家。
一个人可以走的很快,但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎扫码加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/0fe69e9989a88b2772081f7d4efd7454.png)
同步块:synchronized (obj){ }
obj 称之为 同步监视器
obj 可以是任何对象,但是推荐使用共享资源作为同步监视器
同步方法中无需指定同步监视器,因为同步方法的同步监视器就是this,就是和这个对象本身,或者是class
同步监视器的执行过程
1.第一个线程访问,锁定同步监视器,执行其中代码
2.第二个线程访问,发现同步监视器,无法访问
3.第一个线程访问完毕,解锁同步监视器
4.第二个线程访问,发现同步监视器没有锁,然后锁定并访问
锁的对象就是变化的量,需要增删改的数据
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则几千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
[外链图片转存中…(img-rKx5LHm9-1712628027933)]
[外链图片转存中…(img-q79qQSXF-1712628027934)]
[外链图片转存中…(img-7s4DCdIx-1712628027935)]
[外链图片转存中…(img-uzwAKmHb-1712628027935)]
[外链图片转存中…(img-xcc6LTQc-1712628027935)]
[外链图片转存中…(img-I2ie9DRE-1712628027936)]
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录大纲截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且后续会持续更新
如果你觉得这些内容对你有帮助,可以添加V获取:vip1024b (备注Java)
[外链图片转存中…(img-O0HbGEQF-1712628027936)]
最后
无论是哪家公司,都很重视基础,大厂更加重视技术的深度和广度,面试是一个双向选择的过程,不要抱着畏惧的心态去面试,不利于自己的发挥。同时看中的应该不止薪资,还要看你是不是真的喜欢这家公司,是不是能真的得到锻炼。
针对以上面试技术点,我在这里也做一些分享,希望能更好的帮助到大家。
[外链图片转存中…(img-fPnRXvrZ-1712628027937)]
[外链图片转存中…(img-CAxmIdOB-1712628027937)]
[外链图片转存中…(img-iCTyTBJO-1712628027937)]
一个人可以走的很快,但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎扫码加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
[外链图片转存中…(img-UDb5mUED-1712628027938)]