2019-7-19 [JavaSE] 单例多线程 死锁 wait与sleep 生产消费者模式 守护线程 网络 协议 IP 查询IP 域名 端口 URL查询 数据传输实例

最新推荐文章于 2020-10-22 22:38:59 发布
最新推荐文章于 2020-10-22 22:38:59 发布
阅读量580 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45172861/article/details/96494156
版权

文章目录

0.单例 在多线程里会怎样？

//懒汉式
/*class Single{
	private static Single single;// null
	private Single() {}
	synchronized public static Single getInstance() {
		if(single == null) {
			single = new Single();
		}
		return single;
	}
}*/
// 饿汉
/*class Single{
	private static Single single = new Single();
	private Single() {}
	synchronized public static Single getInstance() {
		return single;
	}
}*/

// 最佳
class Single{
	// 静态内部类
	private static class SingleInstance{
		private static Single single = new Single();// 加载初始化
	}
	public static Single getInstance() {
		return SingleInstance.single;//返回对象
	}
}
public class TestSingle {
	public static void main(String[] args) throws ClassNotFoundException {
		
		new Thread(new Runnable() {
			public void run() {
				System.out.println(Single.getInstance());// 对象信息
			}
		}).start();
		
		new Thread(new Runnable() {
			public void run() {
				System.out.println(Single.getInstance());// 对象信息
			}
		}).start();
		
/*		Single single1 = Single.getInstance();
		Single single2 = Single.getInstance();
		System.out.println(single1);//
		System.out.println(single2);//
*/
	}
}

答：都不好，最佳的如上所示

1.死锁

在这里插入图片描述

class Zhangsan{
	public void say() {
		System.out.println("你给我书，我就给你画");
	}
	public void get() {
		System.out.println("张三获得了书");
	}
}
class Lisi{
	public void say() {
		System.out.println("你给我画，我就给你书");
	}
	public void get() {
		System.out.println("李四获得了画");
	}
}

class Thread1 implements Runnable{
	//
	private static  Zhangsan zhangsan = new Zhangsan();
	private static Lisi lisi = new Lisi();
	// 定义boolean
	public boolean tag = false;
	public void run() {//zhangsan lisi
		if(tag == true) {// 张三  
			synchronized (zhangsan) {// zhangsan
				zhangsan.say();// 说
				try {
					Thread.sleep(1000); // 休息
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				synchronized (lisi) {
					zhangsan.get();
				}
			}
		}else {//李四
			try {
				Thread.sleep(5000);
			} catch (InterruptedException e1) {
				e1.printStackTrace();
			}
			synchronized (lisi) {// lisi 
				lisi.say();
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				synchronized (zhangsan) {
					lisi.get();
				}			
			}
		}
	}
}
public class TestLock {

	public static void main(String[] args) {
		Thread1 td1 = new Thread1();
		td1.tag = true;
		Thread1 td2 = new Thread1();
		td2.tag = false;
		Thread zhangsan = new Thread(td1);
		Thread lisi = new Thread(td2);
		zhangsan.start();
		lisi.start();
	}
}

2.wait和sleep的区别

在这里插入图片描述

class Thread2 implements Runnable{
	int i = 10;// 成员变量
	synchronized public void run() {
		for(;  i>= 0; i--) {
			if(i == 5 && Thread.currentThread().getName().equals("t1")) {
				try {
//					Thread.sleep(1000);// 等待 1000毫秒
//					wait(1000);// 等待 1000毫秒
					wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			if(i == 3) {
				notify();// 唤醒 等待池任意一个
				System.out.println("我醒了");
				//notifyAll();//唤醒等待池所有
			}
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}
}
public class TestWait {

	public static void main(String[] args) {
		Thread2 td1 = new Thread2();
		Thread t1 = new Thread(td1,"t1");
		Thread t2 = new Thread(td1,"t2");
		t1.start();
		t2.start();
	}
}

3.BlockingQeue

生产消费者模式
在这里插入图片描述
在这里插入图片描述

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

/**生产者*/
class Producer implements Runnable{
	//篮子
	private BlockingQueue<Integer> q; 
	public Producer(BlockingQueue<Integer> q) {
		this.q = q;
	}

	@Override
	public void run() {
		//生产 
		for(int i = 1; i <= 10 ; i++) {
			try {
				
				Thread.sleep(2000);// 2秒
				q.put(i);//添加元素 ：阻塞
	//			q.add(i);// 非阻塞，加到第3个后会抛出异常
				System.out.println(Thread.currentThread().getName()+"生产了：" + i);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}			
		}
	}
}

/**消费者*/
class Consumer implements Runnable{
	private BlockingQueue<Integer> q ;

	public Consumer(BlockingQueue<Integer> q) {
		super();
		this.q = q;
	}
	public void run() {
		try {
			Thread.sleep(10000);//等10秒
		} catch (InterruptedException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		for(int i = 1; i <= 10 ; i ++) {
			try {
				Thread.sleep(2000);
				// 阻塞方法
				q.take();
			//	q.remove();//非阻塞，拿到第3个后会抛出异常
				System.out.println(Thread.currentThread().getName()+"消费了：" + i);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}
	}
}
public class TestProducer {

	public static void main(String[] args) {
		//队列
		ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<>(3);
		Producer p = new Producer(q);
		Thread tp = new Thread(p,"生产者");
		Consumer c = new Consumer(q);
		Thread tc = new Thread(c,"消费者");
		tp.start();
		tc.start();
	}
}

4.守护线程

简单的老说，就是子线程与主线程同生共死

class SubThread implements Runnable{
	public void run() {
		Scanner input = new Scanner(System.in);
		System.out.println("-- 输入一个数字:");
		int num = input.nextInt();
		System.out.println("数字是：" + num);
	}
}
public class TestThread {

	public static void main(String[] args) {
		SubThread sub = new SubThread();
		Thread t1 = new Thread(sub,"t1");
		t1.setDaemon(true);// 设置守护线程
		t1.start();	
		System.out.println("主线程结束");
	}
}

5.网络

在这里插入图片描述

6.协议

在这里插入图片描述

7.IP地址

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
获取本机IP:

System.out.println(InetAddress.getLocalHost());

8.InetAddress

在这里插入图片描述
实例如下：

	//IP封装
		// InetAddress: DESKTOP-JBSD6AK/192.168.31.61
		System.out.println(InetAddress.getLocalHost());
		// 根据 主机名 或  IP地址 获得一个 IP封装 InetAddress
		InetAddress net = InetAddress.getByName("DESKTOP-JBSD6AK");
		System.out.println(net);
		System.out.println(net.getHostName());// DESKTOP-JBSD6AK
		System.out.println(net.getHostAddress());//192.168.31.61

9.域名

在这里插入图片描述
DNS：域名解析器

10.端口

在这里插入图片描述

11.URL的6个查询

统一资源定位符。
在这里插入图片描述

URL url = new URL("http://127.0.0.1:7890/data/a.docx?id=1&page=5#hello");
	System.out.println(url.getProtocol());// http，获得协议
	System.out.println(url.getPort());// 7890，获得端口号
	System.out.println(url.getDefaultPort());// 80，获得协议的默认的端口
	System.out.println(url.getQuery());// id=1&page=5，获得查询字符串
	System.out.println(url.getRef());// hello，获得某个片段

12.数据传输

在这里插入图片描述
TCP： 安全的。
C/S: 客户端/服务器。
Socket :客户端
ServerSocket:服务器。
B/S:浏览器 /服务器。
UDP：非安全的。速度快。

1.实例：客户端与服务器之间传输字符串

客户端：client

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

/**客户端*/
public class Clinet {

	public static void main(String[] args) throws UnknownHostException, IOException {
		// 客户端                                          127.0.0.1服务器的IP，服务器的端口
		Socket socket = new Socket(InetAddress.getLocalHost(),7890 );
		//-------------------流-----------------------------
		//获得底层流
		InputStream is = socket.getInputStream();
		OutputStream os = socket.getOutputStream();
		//包装
		Scanner in = new Scanner(is);
		PrintWriter out = new PrintWriter(os,true);//** true
		//---------------------------------------------------
		// 读服务器的信息;
		String sr,sw;
		sr = in.nextLine();//读一行
		System.out.println("服务器说了：" + sr);
		
		// 回： 发信息给服务器
		out.println("我是客户端，我收到了");
		//关流
		socket.close();
	}
}

服务器：Server

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

/**服务器*/
public class Server {

	public static void main(String[] args) throws IOException {
		// 建立一个服务器
		ServerSocket server = new ServerSocket(7890);
		// 获得一个Socket  阻塞
		Socket socket = server.accept();
		//-------------------流---------------------------
		//获得底层的双向流
		InputStream is = socket.getInputStream();//输入
		OutputStream os = socket.getOutputStream();//输出
		//包装
		Scanner in = new Scanner(is);// 
		PrintWriter out = new PrintWriter(os,true);// *** true
		//-----------------------------------------------------------
		String sr ,sw;
		//给客户端 发送一条信息：
		out.println("服务器说你好");
		
		// 读： 读 客户端发过来的信息
		sr = in.nextLine();
		System.out.println("客户端说了：" + sr);
		//关流
		socket.close();		
	}
}

输出如下：

在这里插入图片描述

2.实例：客户端与服务器之间实时聊天

客户端：client

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

/**客户端*/
public class Client {

	public static void main(String[] args) throws UnknownHostException, IOException {
		// 客户端                                          127.0.0.1服务器的IP，服务器的端口
		Socket socket = new Socket(InetAddress.getLocalHost(),7890 );
		//-------------------流-----------------------------
		//获得底层流
		InputStream is = socket.getInputStream();
		OutputStream os = socket.getOutputStream();
		//包装
		Scanner in = new Scanner(is);
		PrintWriter out = new PrintWriter(os,true);//** true
		//---------------------------------------------------
		String sr,sw;
		Scanner input = new Scanner(System.in);
		while(true) {
			sr = in.nextLine();
			System.out.println("服务器说：" + sr);
			//回信息给服务器
			System.out.print("--客户端：");
			sw = input.next();//控制台输入
			out.println(sw);// 写回服务器
			if(sw.equals("end")) {
				break;
			}
		}
		//关流
		socket.close();	
	}
}

服务器：Server

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

/**服务器*/
public class Server {

	public static void main(String[] args) throws IOException {
		// 建立一个服务器
		ServerSocket server = new ServerSocket(7890);
		// 获得一个Socket  阻塞
		Socket socket = server.accept();
		//-------------------流---------------------------
		//获得底层的双向流
		InputStream is = socket.getInputStream();//输入
		OutputStream os = socket.getOutputStream();//输出
		//包装
		Scanner in = new Scanner(is);// 
		PrintWriter out = new PrintWriter(os,true);// *** true
		//-----------------------------------------------------------
		System.out.println("---------服务器-------------");
		//先发一个信息给客户端
		out.println("客户端连接服务器成功");
		//
		String sr,sw;
		Scanner input = new Scanner(System.in);
		while(true) {
			sr = in.nextLine();
			System.out.println("客户端说：" + sr);
			System.out.print("--服务器：");
			sw = input.next();//控制台输入
			out.println(sw);
			if(sw.equals("end")) {
				break;
			}
		}
		//关流
		socket.close();		
	}
}

输出如下：

在这里插入图片描述

13.编写：同步 卖票

在这里插入图片描述

法一：

class Station implements Runnable{
	private int count = 20;
	synchronized public void Ticket() {
		count -= 1;
		System.out.println(
				Thread.currentThread().getName()
				+"卖了一张票，余票为"
				+count);
	}
	@Override
	public void run() {
		for (int i = 1; i <= 10; i++) {
			this.Ticket();;
		}
	}	
}
public class day0719 {

	public static void main(String[] args) {
		
		Station ticket = new Station();
		Thread t1 = new Thread(ticket,"1");
		Thread t2 = new Thread(ticket,"2");
		t1.start();
		t2.start();		
	}
}

法二：

class Station extends Thread{
	private int count = 20;
	synchronized public void Ticket() {
		count -= 1;
		System.out.println(
				Thread.currentThread().getName()
				+"卖了一张票，余票为"
				+count);
	}
	@Override
	public void run() {
		for (int i = 1; i <= 10; i++) {
			this.Ticket();;
		}
	}	
}
景子墨
关注
专栏目录
JavaSE专题-多线程总结.doc
06-03
JavaSE专题的多线程是Java编程中至关重要的一部分，它涉及到如何在单个程序中同时执行多个任务。以下是对多线程技术的详细说明： 1. **多线程技术介绍** - **进程**：一个进程是操作系统分配给应用程序的内存空间...
编程修养(二)
weixin_33739627的博客
03-03 131
11、出错信息的处理—————————你会处理出错信息吗？哦，它并不是简单的输出。看下面的示例：     if ( p == NULL ){        printf ( "ERR: The pointer is NULL/n" );    }    告别学生时代的编程吧。这种编程很不利于维护和管理，出错信息或是提示信息，应该统一处理，而不是像上面这样，写成一个“硬编码”。第10条对这方面的处理...
单例模式
weixin_44054961的博客
10-22 165
23种设计模式——单例模式 下面进行的"冗杂"的文字描述(是从runoob中摘抄的) 一、介绍 概述 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 注意： 1、单例类只能有一个实例。 2、单例类必须自己创建自己的唯一实例。 3、单例类必须给
spring MVC中的controller是单例模式，但是是多线程，各个线程之间不影响！
热门推荐
a363722188的专栏
11-03 3万+
Oracle教程数据库优化 JAVA JAVA教程java基础JAVA框架SpringSpring MVCStrutsStruts1Swing教程JAVA经验JAVA面试多线程面试题常见JAVA面试题智力面试题 PHP PHP教程 WEB WEB教程HTML5Jquery热门插件前端开发 杂项 其他Eclipse代码库工具软件已解决问题常用系统工具应用服务器开源
service层里进行sleep事件
做你想做的人，没有时间的限制，只要愿意，什么时候都可以start。
07-22 3912
今天JJM项目出现里一个问题.tomcat假死. 检查jconsole发现线程累积里很多,但是并没有发现什么实质性的问题. 最终一步一步删减代码,发现是在service层使用了Thread.currentThread.sleep(10000)的缘故. 分析: sleep是线程沉睡,但并不会释放资源.如果在service层沉睡,由于spring管理里service,是单例模式,完全被某个sleep给...
Java实现单例的几种方式
weixin_34315485的博客
03-30 1840
1. 什么是单例模式 单例模式指的是在应用整个生命周期内只能存在一个实例。单例模式是一种被广泛使用的设计模式。他有很多好处，能够避免实例对象的重复创建，减少创建实例的系统开销，节省内存。 2. 单例模式和静态类的区别 首先理解一下什么是静态类，静态类就是一个类里面都是静态方法和静态field，构造器被private修饰，因此不能被实例化。...
JavaSE异常与多线程
06-04
入门级笔记，适合查漏补缺。
javase多线程实现生产者消费者问题
11-01
javase多线程中的经典案例，生产者消费者问题,详细见代码
javase之多线程技术
最新发布
10-16
Java中的多线程技术是Java进阶学习的重要组成部分，它涉及到并发编程的理论与实践，旨在提高程序的执行效率和响应速度。以下是对多线程技术的详细解释： 1. **CPU调度算法原理** - **先来先服务（FCFS）**：按照...
JavaSE单例模式各种写法.doc
06-03
### JavaSE单例模式的各种实现方法 #### 一、懒汉式（线程不安全） **定义：** 懒汉式单例模式是最简单的实现方式之一，它的特点是第一次被调用时才实例化对象。 **代码示例：** ```java public class ...
java使用sleep()方法让当前线程睡眠的两种方式
Zero .
09-09 1万+
第一种： 　在需要程序等待的地方加入这个语句，实现让程序等待，这里的参数1000是以毫秒为单位，即这语句可以让程序等待1秒。 Thread.currentThread().sleep(1000); 第二种： TimeUnit类里的sleep方法。 　TimeUnit类提供的方法，其实底层调用的也是Thread类的sleep方法，让程序进行等待。只不过他在上层根据时间单位进行了封装，如上图，共有7种可以选择，可以方便的选择自己需要的时间单位进行使用。 TimeUnit.DAYS.sleep
2019-7-25 [HTML+JS] 人员信息管理系统1.0
景子墨的博客
07-25 4530
文章目录0.HTML+CSS+JS综合练习1 项目概述2 需求实现2.1 样例展示2.2 步骤实现2.2.1 数据查询 :2.2.2 数据添加 :2.2.3 数据添加优化 :需求1 : 添加的form需要点击 "添加新人员" 按钮再显示2.2.4 数据删除 :JavaScript splice() 方法1.定义和用法2. 语法3. 返回值4. 说明5. 实例:2.2.5 数据更新 :法一：标准方法...
2019-6-26 [JavaSE] While循环 4个练习题
景子墨的博客
06-26 4268
文章目录1.计算成绩和人数2.查询商品价格并计算总金额3.输出摄氏温度与华氏温度的对照表4.输入年月日，输出此日期是一年中的第几天，判断平年和闰年的情况 1.计算成绩和人数 由用户输入多个学员成绩，当输入-1时结束循环，输出一共输入多少人，和输入的这些学员的总分数，不能把-1加进去 /* //非固定次数循环while 和 do-while 任务一： 计算成绩和人数。 由用户输入多个学员成绩，当输...
2019-6-24 [JavaSE] 算术运算符 关系运算符 逻辑赋值运算符 条件运算符 位运算符 运算符优先级 控制台输入 流程控制语句 分支结构
景子墨的博客
06-24 2197
文章目录1.算术运算符2.关系运算符3.逻辑运算符4.扩展赋值运算符5.条件运算符6.位运算符7.运算符优先级8.控制台输入9.流程控制语句分类9.1分类9.2 流程图10.分支结构语句10.1 单分支10.2 双分支11.编程：1.两个数字比较大小 2.三个数字求最大数12.编程：三种方法实现，两个变量互换。13.编程：1.输入两个数字，计算加减乘除 2.输入一个数字，判断奇偶14.编程：1.判...
[JavaSE] 学习路线 4周时间规划
景子墨的博客
07-20 1735
文章目录知识点：练习题 知识点： 2019-6-21 [JavaSE] 背景.特点.安装.DOS.环境变量.工作原理.进制转换 2019-6-22 [JavaSE] 注释.变量.数据类型.整数.浮点数.字符.布尔.类型转化.运算符 2019-6-24 [JavaSE] 算术运算符 关系运算符 逻辑赋值运算符 条件运算符 位运算符 运算符优先级 控制台输入 流程控制语句 分支结构 2019-6-25...
2019-8-13 [JavaEE] 项目实战:北京市普通高中高考信息管理与分析系统 2 学生信息展示升级 学生信息添加 报错提示页面
景子墨的博客
08-15 1196
文章目录2.3 学生信息展示升级2.3.1 产品经理阶段2.3.2 项目经理阶段2.3.3 程序员阶段2.3.4 实现过程2.3.4.1 创建视图 stu_v22.3.4.2 编写实体类接收查询结果 StudentScore.java2.3.4.3 修改学生类 Student.java2.3.4.4 修改DAOImpl类2.3.4.5 修改页面展示2.4 学生信息添加2.4.1 产品经理阶段2.4...
2019-8-2 [Java_JSP] request对象 getRequestDispatcher进阶 MVC模式 EL与JSTL response对象 转发与重定向的具体应用
景子墨的博客
08-02 1000
文章目录1. JSP优化1.1 JSP的内置对象1、request对象2、response对象3、session对象4、application对象5、out 对象6、pageContext 对象7、config 对象8、page 对象9、exception 对象2 request对象2.1 传输一个HelloWorld2.1.1 a.jsp将表单需要往b.jsp传入一个文本内容2.1.1b.js...
2019-8-13 [JavaEE] 项目实战:北京市普通高中高考信息管理与分析系统 3 学生信息删除 学生信息更新
景子墨的博客
08-15 976
文章目录2.5 学生信息删除2.5.1 产品经理阶段2.5.2 项目经理阶段2.5.3 程序员阶段2.5.4 实现过程2.5.3.1 DAO层方法2.5.3.2 DAO层实现2.5.3.3 Service层接口2.5.3.4 Service层实现类2.5.3.5 页面JS2.5.3.6 后端控制器2.5.5 效果展示2.6 学生信息更新2.6.1 产品经理阶段2.6.2 项目经理阶段2.6.3 程...
2019-7-24 [HTML_JavaScript] js引用 行内/内部/外部引用 注释 定义变量/数组 JSON[数据格式 定义] 调错 JS函数[语法 无参 有参 触发 预定义]
景子墨的博客
07-24 969
文章目录0.网页脚本技术 JavaScript1 JavaScript概述1.1 什么是JavaScript?1.2 JavaScript特点1.3 JavaScript的基础结构1.4 入门小程序2 JavaScript入门2.1 js的引用方法2.1.1 行内引用2.1.2 内部引用2.1.3 外部引用3 JavaScript编程基础3.1 核心语法详解3.1.1 定义注释3.1.2 定义变...
JavaSE多线程编程详解：创建与管理
"JavaSE多线程编程专题.pptx" 在JavaSE中，多线程编程是一项核心技能，它允许程序并发执行多个任务，提高系统资源利用率和响应速度。多线程涉及到进程和线程两个概念。进程是操作系统分配资源的基本单位，每个进程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值