-
IISGuarder安全守护
2008-12-26 21:20:00功能介绍:1.防盗链、防下载、和流媒体防盗链2. 可以针对不同站点设置防盗链的过滤, 防止图片、... 5. 防盗链目录、防下载目录和流量控制目录可以指定, 不同目录可以指定不同的扩展名。6. 防盗链重定向页面可以根据不功能介绍:
1.防盗链、防下载、和流媒体防盗链
>> 下载试用软件
2. 可以针对不同站点设置防盗链的过滤, 防止图片、桌面、软件、音乐、电影被人引用。如果发现请求者是盗用网站链接, 则自动重定向到错误处理页面
3. 可以指定网站相关目录资源防止被下载。
4. 能够指定信任站点,信任站点可以链接保护资源。
5. 防盗链目录、防下载目录和流量控制目录可以指定, 不同目录可以指定不同的扩展名。
6. 防盗链重定向页面可以根据不同扩展名指向不同页面。
7. 请求者请求不存在的资源时自动重定向到指定页面。
8. 支持流媒体防盗链, 包括Flash和电影在线播放, 音乐在线播放. 流媒体盗链采用64位加密技术。
9. 采用C++编写, 处理速度快, 占用资源极少。效率要比.net php asp 这类脚本解释的效率要高得多。
10. 能随时停止防盗链功能
11. 不用对现有的程序、数据库、文件路径做任何的修改,也不怕嗅探文件真实路径。实施成本低。
12. 支持多语言目前支持简体中文,繁体中文,英文。 -
浪花DNS劫持插件V2.0 突破屏蔽360 7.0安全杀毒/主动防御/过世界杀软/微体积
2010-04-17 14:14:05现公布测试样本(样本代码不含注入进程和守护进程):{ring0循环启发式}浪花DNS劫持插件V2.0 突破屏蔽360安全杀毒/主动防御/过世界杀软/微体积 (未加壳24KB) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~... -
Java SE实践教程 源代码 下载
2010-09-13 08:58:39本书从编程技术、项目实践以及软件工程的角度出发,如果大家想学习基础语法部分,建立去下载别的书籍。当然这本书也讲解了语法,是从实战的角度讲解的。 目录回到顶部↑第1章 进驻爪哇岛——JAVA的基本语法. 1 1.1 ... -
Java SE实践教程 pdf格式电子书 下载(一) 更新
2010-11-11 12:42:03第5章 如何走得更稳——测试驱动的基本概念 91 5.1 讲解 92 5.1.1 什么是JUnit 92 5.1.2 使用JUnit的一般过程 92 5.1.3 安装JUnit 93 5.2 编写单元测试 93 5.2.1 第1个单元测试 93 5.3 编写单元测试的步骤 95... -
Java SE实践教程 pdf格式电子书 下载(四) 更新
2010-11-11 12:46:44第5章 如何走得更稳——测试驱动的基本概念 91 5.1 讲解 92 5.1.1 什么是JUnit 92 5.1.2 使用JUnit的一般过程 92 5.1.3 安装JUnit 93 5.2 编写单元测试 93 5.2.1 第1个单元测试 93 5.3 编写单元测试的步骤 95... -
adb 的运行原理是 PC 端的 adb server 与手机端的守护进程 adbd 建立连接,然后 PC 端的 adb client 通过 adb server 转发命令,adbd 接收命令后解析运行。 所以如果 adbd 以普通权限执行,有些需要 root 权限才能...
-
✅ 在线AI图像处理:一款免下载免注册的在线图像处理工具,支持黑白照片上色、图像无损放大、人像漫画化 - 更多介绍 2020年6月1号添加 timeromantic - Github ✅ 鱼塘热榜:专注摸鱼的趣味新闻热榜网站 - 更...
-
分析函数的内存前几条指令中有没有跳转)、完整性校验(检查文件load command 的修改,获取内存中运行代码的md5值;是否重签名,从可执行文件的LC_CODE_SIGNATURE 读取信息,拿到当前的签名文件的签名信息和编译前...
-
3.3.0 守护进程 3.3.1 多线程的优缺点 3.3.2 长连接与短连接 3.3.3 二分图应用于最佳匹配问题(游客对房间的满意度之和最大问题) 3.3.4 class与struct的区别? 3.3.5 虚函数和纯虚函数 3.3.6 menset()函数 ...
-
芯片在设计上考虑了功能安全的设计,可以达到ASIL B的级别。 这方面我没有太多的ARM平台的经验,恰好借助这个平台了解一下。 虽说按照一般的认知,SDK比自己手写驱动要简单。但是关于SDK的使用,我也没有太多经验...
-
Centos7.5安装cd5.9.3-hadoop2.6.0
2018-12-16 09:11:511.1 只安装一台虚拟机 内存分配4g,所以搭建了伪分布式,将所有的守护进程运行在一个节点首先是配置虚拟机环境(联通外网),然后安装jdk及卸载openjdk,关闭防火墙及安全子系统,并设置开机不启动。 1.2 配置...由于对版本信息不是很清楚,所以选择了5.9.3这个版本,组件下载链接http://archive.cloudera.com/cdh5/cdh/5/
1)hadoop
1.1 只安装一台虚拟机 内存分配4g,所以搭建了伪分布式,将所有的守护进程运行在一个节点首先是配置虚拟机环境(联通外网),然后安装jdk及卸载openjdk,关闭防火墙及安全子系统,并设置开机不启动。
1.2 配置Hadoop ${HADOOP_HOME}---hadoop的安装目录
1.2.1解压命令 tar -zxvf hadoop-2.6.0-cdh5.9.3.tar.gz -C /opt/modules/
配置 hadoop-env.sh mapred-env.sh yarn-env.sh
export JAVA_HOME=/opt/modules/jdk1.8.0_191
1.2.2 配置core-site.xml(hdfs相关配置)
=============core-site.xml===================
<!-- NameNode地址,8020是指定进程8020,访问入口 -->
<property>
<name>fs.defaultFS</name>
<value>hdfs://hostname:8020</value>
</property>
<!-- hadoop在运行时产生的文件,元数据在本地的存放目录 -->
<property>
<name>hadoop.tmp.dir</name>
<value>/opt/modules/ hadoop-2.6.0-cdh5.9.3/data</value>
</property>
============================================
1.2.3
=============hdfs-site.xml============
<!-- 存放到hdfs上的文件的副本数,伪分布式配置为1 -->
<property>
<name>dfs.replication</name>
<value>1</value>
</property>
======================================
1.3 格式化namenode
${HADOOP_HOME}目录下:
$ bin/hdfs namenode -format
1.4 配置YARN 任务调度 (Mapreduce) 资源管理(resourcemanager nodemanager)
${HADOOP_HOME}/etc/hadoop目录下配置yarn-site.xml
=======yarn-site.xml=====
<!-- 指定ResorceManager所在服务器的主机名 -->
<property>
<name>yarn.resourcemanager.hostname</name>
<value>[hostname]</value>
</property>
<!-- 指明在执行MapReduce的时候使用shuffle -->
<property>
<name>yarn.nodemanager.aux-services</name>
<value>mapreduce_shuffle</value>
</property>
====================================
复制并重名模板文件
$ cp etc/hadoop/mapred-site.xml.template etc/hadoop/mapred-site.xml
=======mapred-site.xml=====
${HADOOP_HOME}/etc/hadoop目录下配置mapred-site.xml
<!-- 指定MapReduce基于Yarn来运行 -->
<property>
<name>mapreduce.framework.name</name>
<value>yarn</value>
</property>
=====================================
1.5 配置日志聚合
=======mapred-site.xml=========
**追加到原来配置和后面
<!--指定jobhistory服务的主机及RPC端口号-->
<property>
<name>mapreduce.jobhistory.address</name>
<!--配置实际的主机名和端口-->
<value>[hostname]:10020</value>
</property>
<!-- 指定jobhistory服务的web访问的主机及RPC端口号 -->
<property>
<name>mapreduce.jobhistory.webapp.address</name>
<value>[hostname]:19888</value>
</property>
==============yarn-site.xml=======
<!-- 启用日志聚合功能 -->
<property>
<name>yarn.log-aggregation-enable</name>
<value>true</value>
</property>
<!-- 日志保存时间 -->
<property>
<name>yarn.log-aggregation.retain-seconds</name>
<value>86400</value>
</property>
-
云安服务器卫士.rar
2019-07-14 03:10:24云安服务器卫士自身非常轻巧,同时还具备开机加速、一键检测等多种系统优化功能,可大大加快服务器运行速度,内含的云安服务器卫士软件客服还可帮助用户轻松下载、问题解答,反馈建议等提供帮助。 特点: 1、查杀... -
多线程编程学习笔记
2020-09-16 17:30:14目录概述1、多线程实现方式2、继承Thread1、使用2、网图下载3、实现Runable接口4、并发问题6、龟兔赛跑7、实现Callable接口8、静态代理9、Lambda1、推导lamadba表达式2、带参简化10、线程状态1、线程停止2、线程休眠...目录
概述
笔记参照b站up主:遇见狂神说的视频,链接https://www.bilibili.com/video/BV1V4411p7EF
狂神:只要学不死,就往死里学
1、多线程实现方式
- 继承Thread类
- 实现runable接口
- 实现callable接口
2、继承Thread
1、使用
package com.xwy; /** * @author levi * @create 2020/9/13 5:11 下午 */ //创建线程方法1 集成Thread public class TestThread01 extends Thread{ @Override public void run() { //run方法线程体 for (int i = 0; i < 20; i++) { System.out.println("我在看代码。。。。"+i); } } public static void main(String[] args) { //main线程 ,主线程 // 创建线程对象 TestThread01 testThread01 = new TestThread01(); // 调用start方法开启线程 testThread01.start(); for (int i = 0; i < 2000; i++) { System.out.println("我在学多线程。。。。"+i); } } }
2、网图下载
package com.xwy; import org.apache.commons.io.FileUtils; import java.io.File; import java.io.IOException; import java.net.URL; /** * @author levi * @create 2020/9/13 5:31 下午 */ public class TestThread02 extends Thread{ private String url; private String name; public TestThread02(String url,String name){ this.name = name; this.url = url; } @Override public void run() { WebDownloader webDownloader = new WebDownloader(); webDownloader.downloader(url,name); System.out.println("下载了文件名为"+name+"的文件"); } public static void main(String[] args) { TestThread02 t1= new TestThread02("http://127.0.0.1:8000/file/1.jpg","1.jpg"); TestThread02 t2= new TestThread02("http://127.0.0.1:8000/file/1.jpg","2.jpg"); TestThread02 t3= new TestThread02("http://127.0.0.1:8000/file/1.jpg","3.jpg"); t1.start(); t2.start(); t3.start(); } } //下载器 class WebDownloader{ // 下载方法 public void downloader(String url,String name){ try { FileUtils.copyURLToFile(new URL(url), new File(name)); } catch (IOException e) { e.printStackTrace(); System.out.println("IO异常,downloader方法出现错误"); } } }
3、实现Runable接口
创建线程方式二:实现runable接口,重写run方法,执行线程需要丢入runable接口实现类,调用start方法
package com.xwy; /** * @author levi * @create 2020/9/13 6:06 下午 */ //创建线程方式二:实现runable接口,重写run方法,执行线程需要丢入runable接口实现类,调用start方法 public class TestThread03 implements Runnable{ @Override public void run() { //run方法线程体 for (int i = 0; i < 20; i++) { System.out.println("我在看代码。。。。"+i); } } public static void main(String[] args) { // 创建runable接口的实现对象 TestThread03 testThread03 = new TestThread03(); // 创建线程对象 Thread thread = new Thread(testThread03); // 调用start方法开启线程 thread.start(); // new Thread(testThread03).start(); for (int i = 0; i < 2000; i++) { System.out.println("我在学多线程。。。。"+i); } } }
建议使用实现Runable接口的方式,因为java的单继承局限性
4、并发问题
package com.xwy; /** * @author levi * @create 2020/9/13 6:14 下午 */ public class TestThread04 implements Runnable{ private int ticketNums = 10; @Override public void run() { while (true){ if(ticketNums <= 0){ break; } // 模拟延时 try { Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNums--+"张票"); } } public static void main(String[] args) { TestThread04 ticket = new TestThread04(); new Thread(ticket,"小明").start(); new Thread(ticket,"老师").start(); new Thread(ticket,"黄牛").start(); } } 小明拿到了第8张票 黄牛拿到了第10张票 老师拿到了第9张票 小明拿到了第7张票 老师拿到了第6张票 黄牛拿到了第7张票 老师拿到了第5张票 小明拿到了第5张票 黄牛拿到了第5张票 老师拿到了第4张票 黄牛拿到了第3张票 小明拿到了第4张票 黄牛拿到了第2张票 老师拿到了第2张票 小明拿到了第1张票
出现问题:同一张票被多人拿到
6、龟兔赛跑
package com.xwy; /** * @author levi * @create 2020/9/13 6:22 下午 */ public class Race implements Runnable{ // 胜利者 private static String winner; @Override public void run() { for (int i = 0; i <= 100; i++) { // 模拟兔子休息 if (Thread.currentThread().getName().equals("兔子") && i%10 ==0){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } // 判断比赛是否结束 boolean flag = gameover(i); // 如果比赛结束就停止程序 if(flag){ break; } System.out.println(Thread.currentThread().getName()+"--->跑了"+i+"步"); } } // 判断是否完成了比赛 private boolean gameover(int steps){ if(winner!=null){ return true; }{ if (steps>=100){ winner = Thread.currentThread().getName(); System.out.println("winner is "+winner); return true; } } return false; } public static void main(String[] args) { Race race = new Race(); new Thread(race,"兔子").start(); new Thread(race,"乌龟").start(); } }
这里我设置成10ms兔子也参与不进来。。。,可能电脑运行太快了吧 假装不开心~
7、实现Callable接口
用callable重新实现图片下载
package com.xwy02; import com.xwy.TestThread02; import org.apache.commons.io.FileUtils; import java.io.File; import java.io.IOException; import java.net.URL; import java.util.concurrent.*; /** * @author levi * @create 2020/9/13 8:54 下午 */ public class TestCallable implements Callable<Boolean> { private String url; private String name; public TestCallable(String url,String name){ this.name = name; this.url = url; } @Override public Boolean call() { WebDownloader webDownloader = new WebDownloader(); webDownloader.downloader(url,name); System.out.println("下载了文件名为"+name+"的文件"); return true; } public static void main(String[] args) throws ExecutionException, InterruptedException { TestCallable t1= new TestCallable("http://127.0.0.1:8000/file/1.jpg","1.jpg"); TestCallable t2= new TestCallable("http://127.0.0.1:8000/file/1.jpg","2.jpg"); TestCallable t3= new TestCallable("http://127.0.0.1:8000/file/1.jpg","3.jpg"); // 1创建执行服务 ExecutorService ser = Executors.newFixedThreadPool(3); // 2提交执行 Future<Boolean> r1 = ser.submit(t1); Future<Boolean> r2 = ser.submit(t2); Future<Boolean> r3 = ser.submit(t3); // 3获取结果 boolean rs1 = r1.get(); boolean rs2 = r2.get(); boolean rs3 = r3.get(); // 4关闭服务 ser.shutdown(); } } //下载器 class WebDownloader{ // 下载方法 public void downloader(String url,String name){ try { FileUtils.copyURLToFile(new URL(url), new File(name)); } catch (IOException e) { e.printStackTrace(); System.out.println("IO异常,downloader方法出现错误"); } } }
callable的好处:
- callable可以定义返回值
- 可以抛出异常
8、静态代理
结婚:
- 你:真实角色
- 婚庆公司: 代理你,帮你处理结婚的事情
- 结婚:实现都实现结婚接口
静态代理模式:
- 真是对象和代理对象都要实现同一个接口
- 代理对象要代理真实角色
好处:
- 代理对象可以做好多真实对象做不了的事情
- 真实对象专注做自己的事情
package com.proxystate; /** * @author levi * @create 2020/9/13 9:04 下午 */ public class StateProxy{ public static void main(String[] args) { WeddingCompany weddingCompany = new WeddingCompany(new You()); weddingCompany.HappyMarry(); } } interface Marry{ void HappyMarry(); } //真实角色:我要结婚 class You implements Marry{ @Override public void HappyMarry() { System.out.println("xxx和xwy结婚了"); } } //代理角色 帮助你结婚 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 before(){ System.out.println("结婚前布置现场"); } private void after(){ System.out.println("结婚之后收尾款"); } }
代理模式在多线程内使用:
package com.proxystate; /** * @author levi * @create 2020/9/13 9:04 下午 */ public class StateProxy{ public static void main(String[] args) { You you = new You(); new Thread( ()-> System.out.println("我爱你") ).start(); new WeddingCompany(you).HappyMarry(); // WeddingCompany weddingCompany = new WeddingCompany(you); // weddingCompany.HappyMarry(); } } interface Marry{ void HappyMarry(); } //真实角色:我要结婚 class You implements Marry{ @Override public void HappyMarry() { System.out.println("xxx和xwy结婚了"); } } //代理角色 帮助你结婚 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 before(){ System.out.println("结婚前布置现场"); } private void after(){ System.out.println("结婚之后收尾款"); } }
9、Lambda
1、推导lamadba表达式
package com.lamdba; /** * @author levi * @create 2020/9/13 9:39 下午 */ public class TestLamdba { // 3静态内部类 static class Like2 implements ILike { @Override public void lamdba() { System.out.println("I love Lamdba2"); } } public static void main(String[] args) { ILike like = new Like(); like.lamdba(); like = new Like2(); like.lamdba(); // 4 局部内部类 class Like3 implements ILike { @Override public void lamdba() { System.out.println("I love Lamdba3"); } } like = new Like3(); like.lamdba(); // 5匿名内部类,没有类的名字,必须借助接口或父类 like = new ILike() { @Override public void lamdba() { System.out.println("I love Lamdba4"); } }; like.lamdba(); // 6 lamdba简化 like = ()->{ System.out.println("I love Lamdba5"); }; like.lamdba(); } } //1定义一个接口 interface ILike{ void lamdba(); } //2定义一个实现类 class Like implements ILike{ @Override public void lamdba() { System.out.println("I love Lamdba"); } }
2、带参简化
package com.lamdba; /** * @author levi * @create 2020/9/13 9:49 下午 */ public class TestLamdba2 { public static void main(String[] args) { ILove love = (int a) ->{ System.out.println("i love you--->" + a); }; // 1干掉参数类型 love = (a) ->{ System.out.println("i love you--->" + a); }; // 2干掉括号 love = a ->{ System.out.println("i love you--->" + a); }; // 3干掉{} love = a -> System.out.println("i love you--->" + a); love.Love(2); } } interface ILove{ void Love(int a); }
总结:
- 表达式只有一行代码的情况下,才能去掉{},不然必须用代码块包裹
- 接口必须是函数式接口
- 多个参数也可以去掉参数类型,要去掉都去掉,必须加括号
10、线程状态
1、线程停止
- 不推荐使用stop,destory,一般使用标志位停止
- 建议线程正常停止,利用次数,不建议死循环
package com.state; /** * @author levi * @create 2020/9/13 10:01 下午 */ public class TestStop implements Runnable { private boolean flag = true; @Override public void run() { int i = 0; while (flag){ System.out.println("run .......thread..--->"+i++); } } // 转换标志位方法 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("线程该停止了"); } } } }
2、线程休眠
Sleep
- 每个对象都有一个锁,sleep不会释放锁
- sleep存在异常抛出InterruptedException()
- sleep时间达到后进入就绪状态
模拟网络延时
- 放大问题发生性
- 模拟倒计时
package com.state; /** * @author levi * @create 2020/9/13 10:10 下午 */ public class TestSleep2 { public static void main(String[] args) { try { tenDown(); } catch (InterruptedException e) { e.printStackTrace(); } } public static void tenDown() throws InterruptedException { int num = 10; while(true){ Thread.sleep(1000); System.out.println(num--); if(num<=0){ break; } } } }
- 打印当前系统时间
package com.state; import java.text.SimpleDateFormat; import java.util.Date; /** * @author levi * @create 2020/9/13 10:10 下午 */ public class TestSleep2 { public static void main(String[] args) { // try { // tenDown(); // } catch (InterruptedException e) { // e.printStackTrace(); // } Date startTime = new Date(System.currentTimeMillis()); while (true){ try { Thread.sleep(1000); System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime)); startTime = new Date(System.currentTimeMillis()); } catch (InterruptedException e) { e.printStackTrace(); } } } public static void tenDown() throws InterruptedException { int num = 10; while(true){ Thread.sleep(1000); System.out.println(num--); if(num<=0){ break; } } } }
3、线程礼让
- 让当前线程暂停,但是不阻塞
- 运行转为就绪
- cpu重新调度,礼让不一定成功,看cpu心情
package com.state; /** * @author levi * @create 2020/9/13 10:20 下午 */ 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()+"结束执行"); } }
4、线程强制执行
- Join合并线程,待此线程执行完成后,再执行其他线程,其他线程堵塞
- 可以想象成插队
package com.state; /** * @author levi * @create 2020/9/13 10:25 下午 */ public class TestJoin implements Runnable{ @Override public void run() { for (int i = 0; i < 1000; 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 < 500; i++) { if(i == 200){ thread.join(); //插队 } System.out.println("main" + i); } } }
结果,主线程200前,并发执行,200之后,剩下的没执行的线程先执行完,主线程才继续
5、线程状态观测
package com.state; /** * @author levi * @create 2020/9/14 9:44 上午 */ //观察测试线程的状态 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); //new // 观察启动后 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); //输出状态 } } }
6、线程优先级
package com.state; /** * @author levi * @create 2020/9/14 9:56 上午 */ 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(2); t3.start(); t4.setPriority(Thread.MAX_PRIORITY); t4.start(); t5.setPriority(3); t5.start(); t6.setPriority(4); t6.start(); } } class MyPriority implements Runnable{ @Override public void run() { System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority()); } }
- 优先级设定在start之前
- 优先级低只是意味着获得调度的概率低,并不是优先级低就不会被调用,都是看cpu的调度
7、守护线程
- 线程分为用户线程和守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不等待守护进程执行完毕
- 如:后台记录操作日志,监控内存,垃圾回收等待
package com.state; /** * @author levi * @create 2020/9/14 10:16 上午 */ 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 God implements Runnable{ @Override public void run() { while (true){ System.out.println("上帝保佑着你"); } } } //你 class You implements Runnable{ @Override public void run() { for (int i = 0; i < 36500; i++) { System.out.println("你一生都开心的活着"); } System.out.println("====good bye world====="); } }
11、线程同步
1、三大不安全案例
买票问题:
- 好几个人抢到同一张票,或者可能出现-1
银行取钱问题:
- 出现负数
package com.syn; /** * @author levi * @create 2020/9/14 10:53 上午 */ public class UnSafeBank { public static void main(String[] args) { Account account = new Account(100,"结婚基金"); Drawing xwy = new Drawing(account,50,"xwy"); Drawing xxx = new Drawing(account,100,"xxx"); xwy.start(); xxx.start(); } } //账户 class Account{ int money; //余额 String name; //卡名 public Account(int money, String name) { this.money = money; this.name = name; } } //y银行 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(1000); } catch (InterruptedException e) { e.printStackTrace(); } // 卡内余额 = 余额- 取的钱 account.money = account.money - drawingMoney; // 手里的钱 nowMoney = nowMoney + drawingMoney; System.out.println(account.name + "余额为:" + account.money); System.out.println(this.getName()+"手里的钱:"+nowMoney); } }
不安全的集合
package com.syn; import java.util.ArrayList; import java.util.List; /** * @author levi * @create 2020/9/14 11:10 上午 */ //线程不安全的集合 public class UnSafeList { public static void main(String[] args) { List<String> list = new ArrayList<String>(); for (int i = 0; i < 10000; i++) { new Thread(()-> { list.add(Thread.currentThread().getName()); }).start(); } // try { // Thread.sleep(3000); // } catch (InterruptedException e) { // e.printStackTrace(); // } System.out.println(list.size()); } }
2、同步方法和同步块
synchronized关键字
控制对象的访问,每个对象对应一把锁,每个synchronized方法都必须获得该方法的对象的锁才能执行,否则线程会阻塞,方法一旦执行,就独占该锁,直到该方法返回才释放锁,后面被阻塞的线程才能获得这个锁,继续执行。
- 缺陷:若将一个大的方法申明为synchronized将会影响效率
解决三个不安全案例
- 银行取钱
package com.syn; /** * @author levi * @create 2020/9/14 10:53 上午 */ public class UnSafeBank { public static void main(String[] args) { Account account = new Account(1000,"结婚基金"); Drawing xwy = new Drawing(account,50,"xwy"); Drawing xxx = new Drawing(account,100,"xxx"); xwy.start(); xxx.start(); } } //账户 class Account{ int money; //余额 String name; //卡名 public Account(int money, String name) { this.money = money; this.name = name; } } //y银行 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() { // 锁的对象是就是变化的量,需要增删改的量 synchronized (account){ //判断有没有钱 if(account.money-drawingMoney < 0){ System.out.println(Thread.currentThread().getName() + "钱不够取不了"); return; } try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } // 卡内余额 = 余额- 取的钱 account.money = account.money - drawingMoney; // 手里的钱 nowMoney = nowMoney + drawingMoney; System.out.println(account.name + "余额为:" + account.money); System.out.println(this.getName()+"手里的钱:"+nowMoney); } } }
- 买票
package com.syn; import sun.security.krb5.internal.Ticket; /** * @author levi * @create 2020/9/14 10:43 上午 */ //不安全的买票 public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket buyTicket = new BuyTicket(); new Thread(buyTicket,"苦逼的我").start(); new Thread(buyTicket,"牛逼的你").start(); new Thread(buyTicket,"可恶的黄牛").start(); } } class BuyTicket implements Runnable{ // 票 private int ticketNums = 10; private boolean flag = true; @Override public void run() { // 买票 while (flag){ try { buy(); } catch (InterruptedException e) { e.printStackTrace(); } } } private synchronized void buy() throws InterruptedException { // 判断是否有票 if(ticketNums <=0){ flag = false; return; } // 模拟面试 Thread.sleep(100); // 买票 System.out.println(Thread.currentThread().getName() + "拿到了" + ticketNums--); } }
- list
package com.syn; import java.util.ArrayList; import java.util.List; /** * @author levi * @create 2020/9/14 11:10 上午 */ //线程不安全的集合 public class UnSafeList { public static void main(String[] args) { List<String> list = new ArrayList<String>(); for (int i = 0; i < 10000; i++) { new Thread(()-> { synchronized (list){ list.add(Thread.currentThread().getName()); } }).start(); } // try { // Thread.sleep(3000); // } catch (InterruptedException e) { // e.printStackTrace(); // } System.out.println(list.size()); } }
3、JUC
package com.syn; import java.util.concurrent.CopyOnWriteArrayList; /** * @author levi * @create 2020/9/16 2:55 下午 */ //测试juc安全类型的集合 public class TestJUC { public static void main(String[] args) { CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>(); for (int i = 0; i < 10000; i++) { new Thread(()->{ list.add(Thread.currentThread().getName()); }).start(); } try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(list.size()); } }
12、死锁
- 某个同步块同时拥有“两个对象以上的锁”时就会出现死锁的问题
package com.lock; /** * @author levi * @create 2020/9/16 3:01 下午 */ //多个线程互相抱着对方需要的资源,形成僵持 public class DeadLock { public static void main(String[] args) { MakeUp g1 = new MakeUp(0,"灰姑娘"); MakeUp g2 = new MakeUp(1,"白雪公主"); g1.start(); g2.start(); } } //口红 class Lipstick{ } //镜子 class Mirror{ } //化妆 class MakeUp extends Thread{ // 需要的资源只有一份 static Lipstick lipstick =new Lipstick(); static Mirror mirror = new Mirror(); int choice; //选择 String girlName; //使用化妆品的人 MakeUp(int choice,String girlName){ this.choice = choice; this.girlName = girlName; } @Override public void run() { //化妆 try { makeup(); } catch (InterruptedException e) { e.printStackTrace(); } } //化妆,互相持有对方的锁 private void makeup() throws InterruptedException { if(choice == 0){ synchronized (lipstick){ System.out.println(this.girlName+ "获得口红的锁"); Thread.sleep(1000); synchronized (mirror){ //一秒钟后想获得镜子 System.out.println(this.girlName + "获得镜子的锁"); } } }else{ synchronized (mirror){ System.out.println(this.girlName + "获得镜子的锁"); Thread.sleep(2000); synchronized (lipstick){ //一秒钟后想获得口红 System.out.println(this.girlName + "获得口红的锁"); } } } } }
13、Lock
package com.lock; import java.util.concurrent.locks.ReentrantLock; /** * @author levi * @create 2020/9/16 3:21 下午 */ public class TestLock { public static void main(String[] args) { TestLock2 testLock2 = new TestLock2(); new Thread(testLock2).start(); new Thread(testLock2).start(); new Thread(testLock2).start(); } } class TestLock2 implements Runnable{ int ticketNums = 10; // 定义lock锁 private final ReentrantLock lock = new ReentrantLock(); @Override public void run() { while (true){ try { lock.lock();//加锁 if(ticketNums>0){ try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(ticketNums--); }else { break; } }finally { lock.unlock(); //解锁 } } } }
synchronized和lock的对比:
- lock是显式锁(手动开启关闭),synchronized是隐式锁,出了作用域自动释放
- lock只有代码块锁,synchronized有代码块锁和方法锁
- 使用lock锁,jvm花费较少时间来调度线程,性能更好,具备更好的扩展性
- 优先使用顺序:lock - 同步代码块 - 同步方法
14、线程协作
1、生产者消费者
管程法
package com.gaoji; /** * @author levi * @create 2020/9/16 4:51 下午 */ //测试生产者消费者,利用缓冲区解决:管程法 public class TestPc { public static void main(String[] args) { SynContainer container = new SynContainer(); new Productor(container).start(); new Consumer(container).start(); } } //生产者 class Productor extends Thread{ SynContainer container; public Productor(SynContainer container) { this.container = container; } //生产 @Override public void run() { for (int i = 0; i < 100; i++) { container.push(new Chicken(i)); System.out.println("生产了" + i + "只鸡"); } } } //消费者 class Consumer extends Thread{ SynContainer container; public Consumer(SynContainer container) { this.container = container; } //消费 @Override public void run() { for (int i = 0; i < 100; i++) { System.out.println("消费了第" + container.pop().id + "只鸡"); } } } //产品 class Chicken{ int id; //编号 public Chicken(int id) { this.id = id; } } //缓冲区 class SynContainer{ //容器计数器 int count = 0; //需要一个容器大小 Chicken[] chickens = new Chicken[10]; //生产者放入产品 public synchronized void push(Chicken chicken){ //如果容器满了,就需要等待消费者消费 if(count==chickens.length){ //t通知消费者消费,生产等待 try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } //如果没有满,我们就需要丢入产品 chickens[count] = chicken; count++; //通知消费者可以消费了 this.notifyAll(); } //消费者消费产品 public synchronized Chicken pop(){ if(count==0){ //等待生产者生产,消费者等待 try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } //如果可以消费 count--; Chicken chicken = chickens[count]; //通知生产者生产 this.notifyAll(); return chicken; } }
信号灯法
package com.gaoji; /** * @author levi * @create 2020/9/16 5:16 下午 */ //标志位 public class TestPC2 { public static void main(String[] args) { TV tv = new TV(); new Player(tv).start(); new Watcher(tv).start(); } } //生产者 class Player extends Thread{ TV tv; public Player(TV tv){ this.tv = tv; } @Override public void run() { for (int i = 0; i < 20; i++) { if(i%2==0){ this.tv.play("快乐大本营"); }else{ this.tv.play("广告中"); } } } } //消费者 class Watcher extends Thread{ TV tv; public Watcher(TV tv){ this.tv = tv; } @Override public void run() { for (int i = 0; i < 20; i++) { tv.watch(); } } } //产品 class TV{ String voice; //节目 //演员表演观众等待 T //观众观看,演员等待 F boolean flag = true; //表演 public synchronized void play(String voice){ if(!flag){ try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("演员表演了" + voice); //通知观众观看 this.notifyAll(); this.voice = voice; this.flag = !this.flag; } //观看 public synchronized void watch(){ if(flag){ try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("观看了" + voice); //通知演员表演 this.notifyAll(); this.flag = !this.flag; } }
2、线程池
package com.gaoji; import java.util.concurrent.Executor; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** * @author levi * @create 2020/9/16 4:43 下午 */ public class TestPool { public static void main(String[] args) { //1创建线程池 ExecutorService service = Executors.newFixedThreadPool(10);//参数为i线程池大小 service.execute(new MyThread()); service.execute(new MyThread()); service.execute(new MyThread()); service.execute(new MyThread()); //2关闭连接 service.shutdown(); } } class MyThread implements Runnable{ @Override public void run() { System.out.println(Thread.currentThread().getName()); } }
-
Linux系统管理技术手册第二版(中文)一,共3个
2014-07-11 14:13:53下载注意文件的大小,有时候因为网络不稳定下载的文件有问题要重新下载(本人深受其害,8个Part下了共几十次),解压的时候会提示哪个part有问题。除part8外其他都是19.0M(1个part) 第1章 从何处入手 第2章 引导和... -
linux系统管理手册第二版2(part4-6)
2014-07-11 14:22:18下载注意文件的大小,有时候因为网络不稳定下载的文件有问题要重新下载(本人深受其害,8个Part下了共几十次),解压的时候会提示哪个part有问题。除part8外其他都是19.0M(1个part)。 第1章 从何处入手 第2章 引导... -
linux系统管理手册第二版3(part7-8)
2014-07-11 14:25:06下载注意文件的大小,有时候因为网络不稳定下载的文件有问题要重新下载(本人深受其害,8个Part下了共几十次),解压的时候会提示哪个part有问题。除part8外其他都是19.0M(1个part)。 第1章 从何处入手 第2章 引导... -
TCP/IP技术大全(中文PDF非扫描版)
2015-08-12 14:56:2316.9.5 安全 166 16.10 LDAP配置 169 16.11 产品环境 169 16.11.1 创建计划 170 16.11.2 有价值的建议 171 16.12 选择LDAP软件 171 16.13 小结 174 第17章 远程访问协议 175 17.1 远程互联 175 17.1.1 ISDN 176 ... -
TCP-IP协议详解
2008-11-24 20:46:5016.9.5 安全 166 16.10 LDAP配置 169 16.11 产品环境 169 16.11.1 创建计划 170 16.11.2 有价值的建议 171 16.12 选择LDAP软件 171 16.13 小结 174 第17章 远程访问协议 175 17.1 远程互联 175 17.1.1 ISDN 176 ... -
TCP/IP教程TCP/IP基础
2009-11-23 20:58:4616.9.5 安全 166 16.10 LDAP配置 169 16.11 产品环境 169 16.11.1 创建计划 170 16.11.2 有价值的建议 171 16.12 选择LDAP软件 171 16.13 小结 174 第17章 远程访问协议 175 17.1 远程互联 175 17.1.1 ISDN 176 ... -
绿色免安装 软媒魔方
2015-04-22 17:15:43radar.exe:软媒系统雷达,监控系统的资源信息,网络端口、上传下载以及系统温度信息。 ramdisk.exe:软媒内存盘,把内存当硬盘用!瞬间提高系统运行速度,延长硬盘寿命,降低噪音! rmup.exe:软媒升级程序。 ... -
网络技术学习大全(TCPIP)1.rar
2008-10-17 10:42:0316.9.5 安全 166 16.10 LDAP配置 169 16.11 产品环境 169 16.11.1 创建计划 170 16.11.2 有价值的建议 171 16.12 选择LDAP软件 171 16.13 小结 174 第17章 远程访问协议 175 17.1 远程互联 175 17.1.1 ISDN 176 ... -
KFTPgrabber图形化客户端
2011-04-09 12:58:15分布式的FTP 守护程序支持(实施预处理的命令) 可以使用本地站点发现Zeroconf 其他FTP客户端导入书签插件 为SFTP协议支持 一个不错的交通图 能够限制上传和下载速度 跳过列出优先级和使用先进的过滤规则 集成 SFV ... -
TCP-IP技术大全
2007-12-18 15:42:09服务器通信 161 16.8.1 LDAP数据互换格式(LDIF) 161 16.8.2 LDAP复制 162 16.9 设计LDAP服务 162 16.9.1 定义需求 162 16.9.2 设计策略 163 16.9.3 性能 164 16.9.4 网络功能 165 16.9.5 ... -
LINUX系统分析与高级编程技术
2010-09-17 22:56:0910.13 内核交换守护进程 第十一章 进程间通信 11.1 信号机制 11.2 管理机制 11.3 System V IPC机制 11.3.1 信息队列 11.3.2 信号量 11.3.3 共享内存 第十二章 PCI 12.1 PCI系统 12.2 PCI地址空间 12.3 PCI设置头... -
LINUX系统分析与高级编程技术.rar
2009-05-20 18:26:301.6.1 从网上下载Linux 3 1.6.2 从光盘获得Linux 3 1.7 涉及Linux 的Web 网址和新闻讨论组 6 1.8 Linux 的不足之处 7 第2章 外壳及常用命令 8 2.1 登录和退出 8 2.2 Linux 系统的外壳 8 2.3 外壳的常用命令 9 2.3.1 ... -
RED HAT LINUX 6大全
2011-10-21 18:46:0613.2 启动和停止NFS守护程序 236 13.3 NFS状态 236 13.4 配置NFS服务器和客户 236 13.4.1 建立/etc/exports文件 237 13.4.2 使用mount加载一个导出的文 件系统 238 13.4.3 卸载文件系统 238 13.4.4 配置/etc/fstab... -
Linux-FTP配置说明及安装源文件
2010-12-15 10:45:5320.3.9 超级守护程序启动 vi vsftpd.conf #修改以下内容 listen=NO /*监听2121端口,用于防火墙 */ #在/etc/xinetd.d/新建以下内容 vi /etc/xinetd.d/vsftpd service vsftpd { disable = no socket_type = stream... -
Java代码实例
2016-06-21 22:44:511.2.1 下载JDK 5 1.2.2 安装JDK 6 1.2.3 安装后Java目录的解读 7 1.3 学会使用API 7 1.4 第一个Java程序 8 1.4.1 开发源代码 8 1.4.2 编译运行 9 1.5 小结 11 第2章 基本数据类型——构建Java ... -
迷你版SQL2000服务器
2015-01-23 17:32:372、打开 开始》控制面板》系统和安全》计划任务; 3、创建任务》常规》输入名称》勾选下面的 使用最高权限运行; 触发器》开始任务 选择 登录时》设置 选择 所有用户》高级设置 勾选 启用; 操作》操作 选择 启动... -
Java SE 6.0编程指南 源码
2012-05-18 13:40:451.2.1 下载JDK 5 1.2.2 安装JDK 6 1.2.3 安装后Java目录的解读 7 1.3 学会使用API 7 1.4 第一个Java程序 8 1.4.1 开发源代码 8 1.4.2 编译运行 9 1.5 小结 11 第2章 基本数据类型——构建Java ...