Luckylau's Blog

Keep Moving, Keep Learning


  • 首页

  • 分类

  • 关于

  • 归档

  • 标签

  • 搜索
close
Luckylau's Blog

Java并发之线程工厂和异常处理

发表于 2017-06-20 | 分类于 java

用线程工厂创建线程

ThreadFactory接口实现一个线程对象工厂

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.ThreadFactory;
public class MyTreadFactory implements ThreadFactory {
private int counter;
private String name;
private List<String> stats;
public MyTreadFactory(String name){
counter = 0;
stats = new ArrayList<String>();
this.name = name;
}
@Override
public Thread newThread(Runnable r) {
// TODO Auto-generated method stub
Thread t = new Thread(r, name+"_thread_"+counter);
counter++;
stats.add(String.format("Created thread %d with name %s on %s\n", t.getId(),t.getName(),new Date()));
return t;
}
public String getStats(){
StringBuffer sb = new StringBuffer();
Iterator<String> it = stats.iterator();
while(it.hasNext()){
sb.append(it.next());
sb.append("\n");
}
return sb.toString();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
import java.util.concurrent.TimeUnit;
public class Task implements Runnable{
@Override
public void run() {
try {
TimeUnit.SECONDS.sleep(1);
System.out.println(Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Main {
public static void main(String[] args) {
MyTreadFactory factory = new MyTreadFactory("threadFactory");
Task task = new Task();
Thread thread;
System.out.println("Starting the Threads ");
for (int i = 0; i < 10; i++) {
thread = factory.newThread(task);
thread.start();
try {
thread.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("Finish the Threads ");
System.out.println("Factory stats:");
System.out.printf("%s\n",factory.getStats());
}
}

在线程中处理不受控制的异常

在一个线程对象的run()方法里抛出一个检查异常,我们必须捕获并处理它们。因为run( )方法不接受throws子句。当一个非检查异常抛出,默认的的行为是在控制台写下stack trace并退出程序。

1
2
3
4
5
6
7
8
9
10
11
12
public class Task implements Runnable{
private int num =8;
private int res =0;
@Override
public void run() {
while(true){
res=12/num;
System.out.println("res: " +res );
num --;
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
import java.lang.Thread.UncaughtExceptionHandler;
public class ExceptionHandler implements UncaughtExceptionHandler{
@Override
public void uncaughtException(Thread t, Throwable e) {
// TODO Auto-generated method stub
System.out.printf("An exception has been captured\n");
System.out.printf("Thread:%s\n",t.getId());
System.out.printf("Exception:%s :%s\n",e.getClass().getName(),e.getMessage());
System.out.printf("Stack Traace");
e.printStackTrace(System.out);
System.out.printf("Thread status:%s\n",t.getState());
}
}
1
2
3
4
5
6
7
8
public class Main {
public static void main(String[] args) {
Task task = new Task();
Thread thread = new Thread(task);
thread.setUncaughtExceptionHandler(new ExceptionHandler());
thread.start();
}
}
Luckylau's Blog

Java并发之同步控制

发表于 2017-06-19 | 分类于 java

synchronized

在Java中,synchronized是用来表示同步的,我们可以synchronized来修饰一个方法。也可以synchronized来修饰方法里面的一个语句块。但是要注意在static方法和非static方法使用synchronized。大家都知道,static的方法属于类方法,它属于这个类,那么static获取到的锁,是属于类的锁。而非static方法获取到的锁,是属于当前对象的锁。

阅读全文 »
Luckylau's Blog

Java并发之守护线程

发表于 2017-06-19 | 分类于 java

java的Thread类和Runnable接口

守护线程

​ Thread有两种线程,即“守护线程Daemon”与“用户线程User”。守护线程的优先级非常低,通常在程序里没有其他线程运行时才会执行它。当守护线程是程序里唯一在运行的线程时,JVM会结束守护线程并终止程序。守护线程通常用于在同一程序里给普通线程(也叫使用者线程)提供服务。它们通常无限循环的等待服务请求或执行线程任务。它们不能做重要的任务,因为我们不知道什么时候会被分配到CPU时间片,并且只要没有其他线程在运行,它们可能随时被终止。JAVA中最典型的这种类型代表就是垃圾回收器。

​ setDaemon(boolean on)方法可以方便的设置线程的Daemon模式,true为Daemon模式,此方法必须在线程启动之前调用,当线程正在运行时调用会产生异常。当一个守护线程中产生了其他线程,那么这些新产生的线程不用设置Daemon属性,都将是守护线程。Java垃圾回收线程就是一个典型的守护线程,当我们的程序中不在有任何运行中的Thread,程序就不会再产生垃圾,垃圾回收器也就无事可做,所以当垃圾回收线程是Java虚拟机上仅剩的线程时,Java虚拟机会自动离开。

阅读全文 »
Luckylau's Blog

Java基础之抽象类和接口

发表于 2017-06-18 | 分类于 java

java的抽象类和接口

什么是java的抽象类和接口?

​ abstract class和interface是Java语言中对于抽象类定义进行支持的两种机制,正是由于这两种机制的存在,才赋予了Java强大的面向对象能力。 在面向对象的概念中,我们知道所有的对象都是通过类来描绘的,但是反过来却不是 这样。并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。抽象类往往用来表征我们在对问题领 域进行分析、设计中得出的抽象概念,是对一系列看上去不同,但是本质上相同的具体概念的抽象。而接口呢,它则是一组规则的集合,它规定了实现本接口的类必须拥有的一组规则。体现了自然界“如果你是……则必须能……”的理念。下面详细分析抽象类和接口以及它们之间的区别。

阅读全文 »
Luckylau's Blog

HTTP和HTTPS解读

发表于 2017-06-16 | 分类于 网络

Http 与 Https的区别

​ Hyper Text Transfer Protocol,超文本传输协议,是互联网上使用最广泛的一种协议,所有WWW文件必须遵循的标准。HTTP协议传输的数据都是未加密的,也就是明文的,因此使用HTTP协议传输隐私信息非常不安全。
​ Hyper Text Transfer Protocol over Secure Socket Layer,安全的超文本传输协议,网景公司设计了SSL(Secure Sockets Layer)协议用于对Http协议传输的数据进行加密,保证会话过程中的安全性。
HTTP 和 HTTPS 的不同之处:

HTTP 的 URL 以 http:// 开头,而 HTTPS 的 URL 以 https:// 开头
HTTP 是不安全的,而 HTTPS 是安全的
HTTP 标准端口是 80 ,而 HTTPS 的标准端口是 443
在 OSI 网络模型中,HTTP 工作于应用层,而 HTTPS 工作在传输层
HTTP 无需加密,而 HTTPS 对传输的数据进行加密
HTTP 无需证书,而 HTTPS 需要认证证书

阅读全文 »
Luckylau's Blog

Java基础之反射的机制与用途

发表于 2017-06-14 | 分类于 java

java的反射机制

什么是java.lang.Class类?

​ 众所周知Java有个Object类,是所有Java类的继承根源,其内声明了数个应该在所有Java类中被改写的方法:hashCode()、equals()、clone()、toString()、getClass()等。其中getClass()返回一个Class类的对象。

​ Class类十分特殊。它和一般class一样继承自Object,其实体用以表达Java程序运行时的class和interface,也用来表达enum、array、primitive Java types(boolean, byte, char, short, int, long, float, double)以及关键词void,也就是说运行时的class和interface,基本的 Java 类型(boolean、byte、char、short、int、long、float 和 double)和关键字 void 也都对应一个 Class 对象。 Class 没有公共构造方法,Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的一个Class object(对象),因此不能显式地声明一个Class对象。

​ 每个数组属于被映射为 Class 对象的一个类,所有具有相同元素类型和维数的数组都共享该 Class 对象。

​ 一般某个类的Class对象被载入内存,它就用来创建这个类的所有对象。

阅读全文 »
1…232425…36
Luckylau

Luckylau

人生识字忧患始

215 日志
14 分类
33 标签
GitHub Weibo
© 2017 - 2022 Luckylau
由 Hexo 强力驱动
主题 - NexT.Pisces