1.多线程方法
* Thread 里面的俩个方法
* 1.yield让出CPU,又称为礼让线程
* 2.setPriority()设置线程的优先级
* 优先级最大是10,Thread.MAX_PRIORITY,最小是1,Thread.MIN_PRIORITY
2.单例设计模式
* 单例设计模式:保证类在内存中只有一个对象。
* 如何保证类在内存中只有一个对象呢?
* (1)控制类的创建,不让其他类来创建本类的对象。private
* (2)在本类中定义一个本类的对象。Singleton s;
* (3)提供公共的访问方式。 public static Singleton getInstance(){return s}
* 单例写法两种:
* (1)饿汉式 开发用这种方式。
*
//饿汉式
class Singleton {
//1,私有构造函数,private修饰该类
private Singleton(){}
//2,创建本类对象,private static (私有静态的对象)
private static Singleton s = new Singleton();
//3,对外提供公共的访问方法(static 静态的访问方式)
public static Singleton getInstance() {
return s;
} public static void print() {
System.out.println("11111111111");
}
}
* (2)懒汉式 面试写这种方式。多线程的问题?
*
//懒汉式,单例的延迟加载模式
class Singleton {
//1,私有构造函数
private Singleton(){}
//2,声明本类对象引用
private static Singleton s;
//3,对外提供公共的访问方法
public static Singleton getInstance() {
if(s == null)
//线程1,线程2
s = new Singleton();
return s;
} public static void print() {
System.out.println("11111111111");
}
}
* (3)第三种格式
*
class Singleton {
private Singleton() {} public static final Singleton s = new Singleton();//final是最终的意思,被final修饰的变量不可以被更改
}
3.Runtime类
* Runtime类是一个单例类,返回与当前 Java 应用程序相关的运行时对象。
* 每个 Java 应用程序都有一个 Runtime 类实例,使应用程序能够与其运行的环境相连接。可以通过 getRuntime 方法获取当前运行时。
Runtime r = Runtime.getRuntime(); //获取该类的唯一的对象
//r.exec("shutdown -s -t 300"); //300秒后关机
r.exec("shutdown -a");
4.Timer类:计时器
public class Demo5_Timer {
/**
* @param args
* 计时器
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException {
Timer t = new Timer();
//Timer类中的schedule()安排指定的时间,执行指定的任务
t.schedule(new MyTimerTask(), new Date(114,9,15,10,54,20),3000); while(true) {
System.out.println(new Date());
Thread.sleep(1000);
}
}
}
//TimerTask 由 Timer 安排为一次执行或重复执行的任务。
class MyTimerTask extends TimerTask {
@Override
public void run() {
System.out.println("起床背英语单词");
}
}
5.两个线程间的通信
* 在同步代码块中锁对象是谁,就用哪个对象来调用wait。
* 为什么wait方法和notify方法需要定义在Object类中(面试)?
* 所有的对象都是Object的子类对象,而所有的对象都可以当作锁对象
* sleep方法和wait方法的区别(面试题)?
* 1,sleep方法必须传入参数,参数就是时间,当时间到了,不用唤醒自动醒来
* wait方法不是必须传入参数,如果没有参数,遇到wait就等待,如果传入参数,等参数的时间到后等待
* 2,sleep方法在同步中不释放锁
* wait方法在同步中释放锁。
* 1.什么时候需要通信
* 多个线程并发执行时, 在默认情况下CPU是随机切换线程的
* 如果我们希望他们有规律的执行, 就可以使用通信, 例如每个线程执行一次打印
* 2.怎么通信
* 如果希望线程等待, 就调用wait()
* 如果希望唤醒等待的线程, 就调用notify();
* 这两个方法必须在同步代码中执行, 并且使用同步锁对象来调用。
6.三个或三个以上间的线程通信
* 多个线程通信的问题
* notify()方法是随机唤醒一个线程
* notifyAll()方法是唤醒所有线程
* JDK5之前无法唤醒指定的一个线程
* 如果多个线程之间通信, 需要使用notifyAll()通知所有线程, 用while来反复判断条件。
7.JDK1.5的新特性互斥锁
* 1.同步
* 使用ReentrantLock类的lock()和unlock()方法进行同步
* 2.通信
* 使用ReentrantLock类的newCondition()方法可以获取Condition对象
* 需要等待的时候使用Condition的await()方法, 唤醒的时候用signal()方法
* 不同的线程使用不同的Condition, 这样就能区分唤醒的时候找哪个线程了。
8.线程组的概述和使用
* A:线程组概述
* Java中使用ThreadGroup来表示线程组,它可以对一批线程进行分类管理,Java允许程序直接对线程组进行控制。
* 默认情况下,所有的线程都属于主线程组。
* public final ThreadGroup getThreadGroup()
* 我们也可以给线程设置分组
* Thread(ThreadGroup?group, Runnable?target, String?name)
* 线程组的使用,默认是主线程组
MyRunnable mr = new MyRunnable();
Thread t1 = new Thread(mr, "张三");
Thread t2 = new Thread(mr, "李四");
//获取线程组
// 线程类里面的方法:public final ThreadGroup getThreadGroup()
ThreadGroup tg1 = t1.getThreadGroup();
ThreadGroup tg2 = t2.getThreadGroup();
// 线程组里面的方法:public final String getName()
String name1 = tg1.getName();
String name2 = tg2.getName();
System.out.println(name1);
System.out.println(name2);
// 通过结果我们知道了:线程默认情况下属于main线程组
// 通过下面的测试,你应该能够看到,默任情况下,所有的线程都属于同一个组
System.out.println(Thread.currentThread().getThreadGroup().getName()); * 自己设定线程组
// ThreadGroup(String name)
ThreadGroup tg = new ThreadGroup("这是一个新的组"); MyRunnable mr = new MyRunnable();
// Thread(ThreadGroup group, Runnable target, String name)
Thread t1 = new Thread(tg, mr, "张三");
Thread t2 = new Thread(tg, mr, "李四"); System.out.println(t1.getThreadGroup().getName());
System.out.println(t2.getThreadGroup().getName()); //通过组名称设置后台线程,表示该组的线程都是后台线程
tg.setDaemon(true);
9.线程池的概述和使用
* A:线程池概述
* 程序启动一个新线程成本是比较高的,因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能,尤其是当程序中要创建大量生存期很短的线程时,更应该考虑使用线程池。线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。在JDK5之前,我们必须手动实现自己的线程池,从JDK5开始,Java内置支持线程池
* B:内置线程池的使用概述
* JDK5新增了一个Executors工厂类来产生线程池,有如下几个方法
* public static ExecutorService newFixedThreadPool(int nThreads)
* public static ExecutorService newSingleThreadExecutor()
* 这些方法的返回值是ExecutorService对象,该对象表示一个线程池,可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
* Future<?> submit(Runnable task)
* <T> Future<T> submit(Callable<T> task)
* 使用步骤:
* 创建线程池对象
* 创建Runnable实例
* 提交Runnable实例
* 关闭线程池
* C:案例演示
* 提交的是Runnable
*
// public static ExecutorService newFixedThreadPool(int nThreads)
ExecutorService pool = Executors.newFixedThreadPool(2); // 可以执行Runnable对象或者Callable对象代表的线程
pool.submit(new MyRunnable());
pool.submit(new MyRunnable()); //结束线程池
pool.shutdown();
* 提交的是Callable *
// 创建线程池对象
ExecutorService pool = Executors.newFixedThreadPool(2); // 可以执行Runnable对象或者Callable对象代表的线程
Future<Integer> f1 = pool.submit(new MyCallable(100));
Future<Integer> f2 = pool.submit(new MyCallable(200)); // V get()
Integer i1 = f1.get();
Integer i2 = f2.get(); System.out.println(i1);
System.out.println(i2); // 结束
pool.shutdown(); public class MyCallable implements Callable<Integer> { private int number; public MyCallable(int number) {
this.number = number;
} @Override
public Integer call() throws Exception {
int sum = 0;
for (int x = 1; x <= number; x++) {
sum += x;
}
return sum;
} }
* 多线程程序实现的方式3的好处和弊端
* 好处:
* 可以有返回值
* 可以抛出异常 * 弊端:
* 代码比较复杂,所以一般不用
10.简单工厂模式概述和使用
* A:简单工厂模式概述
* 又叫静态工厂方法模式,它定义一个具体的工厂类负责创建一些类的实例
* B:优点
* 客户端不需要在负责对象的创建,从而明确了各个类的职责
* C:缺点
* 这个静态工厂类负责所有对象的创建,如果有新的对象增加,或者某些对象的创建方式不同,就需要不断的修改工厂类,不利于后期的维护
* D:案例演示
* 动物抽象类:public abstract Animal { public abstract void eat(); }
* 具体狗类:public class Dog extends Animal {}
* 具体猫类:public class Cat extends Animal {}
* 开始,在测试类中每个具体的内容自己创建对象,但是,创建对象的工作如果比较麻烦,就需要有人专门做这个事情,所以就知道了一个专门的类来创建对象。
*
public class AnimalFactory {
private AnimalFactory(){} //public static Dog createDog() {return new Dog();}
//public static Cat createCat() {return new Cat();} //改进
public static Animal createAnimal(String animalName) {
if(“dog”.equals(animalName)) {}
else if(“cat”.equals(animale)) { }else {
return null;
}
}
}
11.工厂方法模式的概述和使用
* A:工厂方法模式概述
* 工厂方法模式中抽象工厂类负责定义创建对象的接口,具体对象的创建工作由继承抽象工厂的具体类实现。
* B:优点
* 客户端不需要在负责对象的创建,从而明确了各个类的职责,如果有新的对象增加,只需要增加一个具体的类和具体的工厂类即可,不影响已有的代码,后期维护容易,增强了系统的扩展性
* C:缺点
* 需要额外的编写代码,增加了工作量
* D:案例演示
*
动物抽象类:public abstract Animal { public abstract void eat(); }
工厂接口:public interface Factory {public abstract Animal createAnimal();}
具体狗类:public class Dog extends Animal {}
具体猫类:public class Cat extends Animal {}
开始,在测试类中每个具体的内容自己创建对象,但是,创建对象的工作如果比较麻烦,就需要有人专门做这个事情,所以就知道了一个专门的类来创建对象。发现每次修改代码太麻烦,用工厂方法改进,针对每一个具体的实现提供一个具体工厂。
狗工厂:public class DogFactory implements Factory {
public Animal createAnimal() {…}
}
猫工厂:public class CatFactory implements Factory {
public Animal createAnimal() {…}
}
12.如何创建一个窗口并显示、布局管理、窗体监视
* Graphical User Interface(图形用户接口)。
*
Frame f = new Frame(“my window”);
f.setLayout(new FlowLayout());//设置布局管理器
f.setSize(500,400);//设置窗体大小
f.setLocation(300,200);//设置窗体出现在屏幕的位置
f.setIconImage(Toolkit.getDefaultToolkit().createImage("qq.png"));
f.setVisible(true);
* FlowLayout(流式布局管理器)
* 从左到右的顺序排列。
* Panel默认的布局管理器。
* BorderLayout(边界布局管理器)
* 东,南,西,北,中
* Frame默认的布局管理器。
* GridLayout(网格布局管理器)
* 规则的矩阵
* CardLayout(卡片布局管理器)
* 选项卡
* GridBagLayout(网格包布局管理器)
* 非规则的矩阵
Frame f = new Frame("我的窗体");
//事件源是窗体,把监听器注册到事件源上
//事件对象传递给监听器
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
//退出虚拟机,关闭窗口
System.exit(0);
}
});
13.适配器设计模式
* a.什么是适配器
* 在使用监听器的时候, 需要定义一个类事件监听器接口.
* 通常接口中有多个方法, 而程序中不一定所有的都用到, 但又必须重写, 这很繁琐.
* 适配器简化了这些操作, 我们定义监听器时只要继承适配器, 然后重写需要的方法即可.
* b.适配器原理
* 适配器就是一个类, 实现了监听器接口, 所有抽象方法都重写了, 但是方法全是空的.
* 目的就是为了简化程序员的操作, 定义监听器时继承适配器, 只重写需要的方法就可以了.
* 事件处理
* 事件: 用户的一个操作
* 事件源: 被操作的组件
* 监听器: 一个自定义类的对象, 实现了监听器接口, 包含事件处理方法,把监听器添加在事件源上, 当事件发生的时候虚拟机就会自动调用监听器中的事件处理方法
适配器、工厂模式、线程池、线程组、互斥锁、Timer类、Runtime类、单例设计模式(二十四)的更多相关文章
-
死锁、Lock锁、等待唤醒机制、线程组、线程池、定时器、单例设计模式_DAY24
1:线程(理解) (1)死锁 概念: 同步中,多个线程使用多把锁之间存在等待的现象. 原因分析: a.线程1将锁1锁住,线程2将锁2锁住,而线程1要继续执行锁2中的代码,线程2要继续执行锁1中的代码, ...
-
android线程与线程池-----线程池(二)《android开发艺术与探索》
android 中的线程池 线程池的优点: 1 重用线程池中的线程,避免了线程的创建和销毁带来的性能开销 2 能有效的控制最大并发数,避免大量线程之间因为喜欢抢资源而导致阻塞 3 能够对线程进行简单的 ...
-
Java多线程面试题:线程锁+线程池+线程同步等
1.并发编程三要素? 1)原子性 原子性指的是一个或者多个操作,要么全部执行并且在执行的过程中不被其他操作打断,要么就全部都不执行. 2)可见性 可见性指多个线程操作一个共享变量时,其中一个线程对变量 ...
-
C# 显式创建线程 or 使用线程池线程--new Thread() or ThreadPool.QueueUserWorkItem()
在C#多线程编程中,关于是使用自己创建的线程(Thread)还是使用线程池(ThreadPool)线程,一直很困惑,知道看了Jeffrey Richter的相关介绍才明白,记录如下: 当满足一下任何条 ...
-
java 线程池线程忙碌且阻塞队列也满了时给一个拒接的详细报告
线程池线程忙碌且阻塞队列也满了时给一个拒接的详细报告.下面是一个自定义的终止策略类,继承了ThreadPoolExecutor.AbortPolicy类并覆盖了rejectedExecution方法把 ...
-
线程池线程数与(CPU密集型任务和I/O密集型任务)的关系
近期看了一些JVM和并发编程的专栏,结合自身理解,来做一个关于(线程池线程数与(CPU密集型任务和I/O密集型任务)的关系)的总结: 1.任务类型举例: 1.1: CPU密集型: 例如,一般我们系统的 ...
-
EventStore .NET API Client在使用线程池线程同步写入Event导致EventStore连接中断的问题研究
最近,在使用EventStore的.NET Client API采用大量线程池线程同步写入Event时(用于模拟ASP.NET服务端大并发写入Event的情况),发现EventStore的连接会随机中 ...
-
JUC源码分析-线程池篇(三)Timer
JUC源码分析-线程池篇(三)Timer Timer 是 java.util 包提供的一个定时任务调度器,在主线程之外起一个单独的线程执行指定的计划任务,可以指定执行一次或者反复执行多次. 1. Ti ...
-
JAVA之旅(十四)——静态同步函数的锁是class对象,多线程的单例设计模式,死锁,线程中的通讯以及通讯所带来的安全隐患,等待唤醒机制
JAVA之旅(十四)--静态同步函数的锁是class对象,多线程的单例设计模式,死锁,线程中的通讯以及通讯所带来的安全隐患,等待唤醒机制 JAVA之旅,一路有你,加油! 一.静态同步函数的锁是clas ...
随机推荐
-
【USACO 3.1】Stamps (完全背包)
题意:给你n种价值不同的邮票,最大的不超过10000元,一次最多贴k张,求1到多少都能被表示出来?n≤50,k≤200. 题解:dp[i]表示i元最少可以用几张邮票表示,那么对于价值a的邮票,可以推出 ...
-
python爬虫学习 —— 总目录
开篇 作为一个C党,接触python之后学习了爬虫. 和AC算法题的快感类似,从网络上爬取各种数据也很有意思. 准备写一系列文章,整理一下学习历程,也给后来者提供一点便利. 我是目录 听说你叫爬虫 - ...
-
MVC Razor模板引擎 @RenderBody、@RenderPage、@RenderSection及Html.RenderPartial、Html.RenderAction
一.Views文件夹 -> Shared文件夹下的 _Layout.cshtml 母版页 @RenderBody 当创建基于_Layout.cshtml布局页面的视图时,视图的内容会和布局页面合 ...
- oracle创建数据库到2%不动问题
-
Oleans集群之Consul再解释
Oleans集群之Consul再解释 这是Orleans系列文章中的一篇.首篇文章在此 由于上周发文章的时候,我正要打算出门,所以就把写好的全部发出去了,有点仓促,虽然写了主线,但是这里还是需要再次解 ...
-
Python笔记之 - 一张截图诠释";文件读写"; !
Python笔记之 - 一张截图诠释"文件读写" ! 源代码如下: # 文件读写 str_test1 = "先创建txt文件再写入内容: 我是大帅哥" # wi ...
-
ArcGIS API for JavaScript与 npm
在4.7版本中,不仅增加了WebGL的渲染支持(渲染前端速度加快,渲染量也加大).增强了ES6中的Promises语法支持,还支持了npm管理及webpack打包,实属喜讯. “意味着可以不经过esr ...
-
checkbox操作判断 Jquery选择器
function checkAll(d){ console.log(d); console.log(d.checked); //注意 这里是d不是$(d) 不是jQuery对象 if(d.checke ...
-
挖矿程序的工作原理(BTC为例)
Mining时代进化:CPU挖矿 -> GPU挖矿 -> FPGA挖矿 -> ASIC挖矿CPU挖矿时代:SENGENERATEGPU挖矿时代:GETWORK Miner:挖矿的程序 ...
-
SpringMVC 的使用映射路径 <;mvc:resources >;
以下是测试结果,可能存在纰漏,暂记录一下. 使用springMVC时,一般将DispatcherServlet请求映射配置为"/",则Spring MVC将捕获Web容器所有的请求 ...