System.out.println(Thread.currentThread().getName());
}
}
class test extends Thread{
@Override
public void run() {
System.out.println(“你好啊”);
}
}
========================================================================
daemon守护线程会因为用户线程关闭而关闭,默认为用户线程
Thread实例对象setDarmon()方法可以设置是否为守护者线程,默认为false。
守护线程会随着用户线程的结束而结束
java守护线程案例如下:
package cn.xjt.demo03;
/**
-
daemon守护线程会因为用户线程关闭而关闭,默认为用户线程
-
y
-
@author xujiangtao
-
@create 2020-08-01-10:36
*/
public class TestDaemon {
public static void main(String[] args) {
God god = new God();
HandsomeYou handsomeyou = new HandsomeYou();
Thread thread = new Thread(god);
thread.setDaemon(true); //上帝守护线程
thread.start();
new Thread(handsomeyou).start();
}
}
class God implements Runnable{
@Override
public void run() {
while (true)
{
System.out.println(“上帝守护着你”);
}
}
}
class HandsomeYou implements Runnable{
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(“Hello world 你开心的活着”);
}
System.out.println(“goodbye world==”);
}
}
==============================================================================================
package cn.xjt.demo03;
/**
-
@author xujiangtao
-
@create 2020-07-31-20:10
*/
public class TestLamda {
//第1步简化->静态内部类
static class son2 implements Like{
@Override
public void lamda() {
System.out.println(“i’m lamda2”);
}
}
public static void main(String[] args) {
Like s = new son1();
s.lamda();
s=new son2();
s.lamda();
//第2步简化->局部内部类
class son3 implements Like{
@Override
public void lamda() {
System.out.println(“i’m lamda3”);
}
}
s=new son3();
s.lamda();
//第3步简化->匿名内部类
s=new Like() {
@Override
public void lamda() {
System.out.println(“i’m Lamda4”);
}
};
s.lamda();
//第4步简化->Lamda
s= ()-> {
System.out.println(“i’m Lamda5”);
};
s.lamda();
}
}
//接口类
interface Like{
void lamda();
}
//正常实现类
class son1 implements Like{
@Override
public void lamda() {
System.out.println(“i’m lamda”);
}
}
==========================================================================
使用生产者消费者模式。通过缓存区,保证产品数量大于消费数量
package cn.xjt.gaoji;
/**
-
测试生产者消费者–>利用缓冲区:管程法
-
@author xujiangtao
-
@create 2020-08-01-21:53
*/
//成产者,消费者,产品,缓存区
public class TestPC {
public static void main(String[] args) {
Syncontainer syncontainer = new Syncontainer();
new Productor(syncontainer).start();
new Consumer(syncontainer).start();
}
}
//生产者
class Productor extends Thread{
Syncontainer container;
public Productor(Syncontainer container)
{
this.container=container;
}
//生产
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
container.push(new Chicken(i));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(“生产了”+(i+1)+“只鸡”);
}
}
}
//消费者
class Consumer extends Thread{
Syncontainer container;
public Consumer(Syncontainer container)
{
this.container=container;
}
//消费
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
System.out.println(“消费了->”+container.pop().id+“只鸡”);
System.out.println(Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//产品
class Chicken{
int id;
Chicken(int id)
{
this.id=id;
}
}
//缓冲区
class Syncontainer{
//需要一个容器大小
Chicken[] chickens = new Chicken[10];
int count =0;
//生产者放入产品
public synchronized void push(Chicken chicken) throws InterruptedException {
//如果容器满了,需要消费者消费
if(count ==chickens.length)
{
this.wait();
}
//如果没有满,就需要生产产品放入
chickens[count] = chicken;
count++;
//可以通知消费者了
this.notifyAll();
}
//消费者消费产品
public synchronized Chicken pop() throws InterruptedException {
//判断缓冲区是否还有产品
if(count==0)
{
//等待生产者生产,消费者等待
this.wait();
}
count–;
return chickens[count];
// this.notifyAll();
//吃完了,通知生产者生产
}
}
package cn.xjt.gaoji;
/**
-
测试生产者,消费者问题 2:信号灯法
-
标志位解决
-
@author xujiangtao
-
@create 2020-08-02-13:11
*/
public class TestPC2 {
public static void main(String[] args) {
TV tv = new TV();
new actor(tv).start();
new watcher(tv).start();
}
}
//生产者->演员
class actor extends Thread{
TV tv;
public actor(TV tv)
{
this.tv=tv;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
if(i%2==0)
{
tv.play(“抖音:记录美好生活”);
System.out.println(i);
}else{
tv.play(“快乐大本营”);
System.out.println(i);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//消费者->观众
class watcher extends Thread{
TV tv;
public watcher(TV tv)
{
this.tv=tv;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
tv.watch(“观众”);
System.out.println(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//产品->Tv
class TV{
String video;
// String Watchername;
boolean flag = true;
//演员表演,观众等待 T
//观众观看,演员等待 F
//表演方法
public synchronized void play(String vidio) throws InterruptedException {
//判断如果是true,则表演节目
if(flag)
{
System.out.println(“演员表演了->”+vidio);
Thread.sleep(1000);
//通知观众观看
this.notifyAll(); //通知观众观看节目
this.video=vidio;
flag=!this.flag;
}else { //否则,等待观众观看
this.wait();
}
}
public synchronized void watch(String watchername) throws InterruptedException {
//判断如果为flase,则观众观看节目
if(!flag)
我的面试宝典:一线互联网大厂Java核心面试题库
以下是我个人的一些做法,希望可以给各位提供一些帮助:
整理了很长一段时间,拿来复习面试刷题非常合适,其中包括了Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等,且还会持续的更新…可star一下!
283页的Java进阶核心pdf文档
Java部分:Java基础,集合,并发,多线程,JVM,设计模式
数据结构算法:Java算法,数据结构
开源框架部分:Spring,MyBatis,MVC,netty,tomcat
分布式部分:架构设计,Redis缓存,Zookeeper,kafka,RabbitMQ,负载均衡等
微服务部分:SpringBoot,SpringCloud,Dubbo,Docker
还有源码相关的阅读学习
watchername) throws InterruptedException {
//判断如果为flase,则观众观看节目
if(!flag)
我的面试宝典:一线互联网大厂Java核心面试题库
以下是我个人的一些做法,希望可以给各位提供一些帮助:
整理了很长一段时间,拿来复习面试刷题非常合适,其中包括了Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等,且还会持续的更新…可star一下!
[外链图片转存中…(img-hoPjqnlE-1719268602111)]
283页的Java进阶核心pdf文档
Java部分:Java基础,集合,并发,多线程,JVM,设计模式
数据结构算法:Java算法,数据结构
开源框架部分:Spring,MyBatis,MVC,netty,tomcat
分布式部分:架构设计,Redis缓存,Zookeeper,kafka,RabbitMQ,负载均衡等
微服务部分:SpringBoot,SpringCloud,Dubbo,Docker
[外链图片转存中…(img-02GZCmVV-1719268602112)]
还有源码相关的阅读学习
[外链图片转存中…(img-NwyEAWZu-1719268602112)]