目录
一、异常
1、异常概念
异常 ：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。
2、异常体系
异常机制其实是帮助我们找到程序中的问题，异常的根类是 java.lang.Throwable ，其下有两个子类：
java.lang.Error 与 java.lang.Exception ，平常所说的异常指 java.lang.Exception 。
Throwable体系：
Error:严重错误Error，无法通过处理的错误，只能事先避免，好比绝症。
Exception:表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。好
比感冒、阑尾炎。
Throwable中的常用方法：
public void printStackTrace() :打印异常的详细信息。
包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。
public String getMessage() :获取发生异常的原因。
提示给用户的时候,就提示错误原因。
public String toString() :获取异常的类型和异常描述信息(不用)。
出现异常,不要紧张,把异常的简单类名,拷贝到API中去查。
3、异常分类
二、异常的处理
Java异常处理的五个关键字：try、catch、finally、throw、throws
1、抛出异常throw
在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。那么，抛出一个异常具体如何操作呢？
1. 创建一个异常对象。封装一些提示信息(信息可以自己编写)。
2. 需要将这个异常对象告知给调用者。怎么告知呢？怎么将这个异常对象传递到调用者处呢？通过关键字throw
就可以完成。throw 异常对象。
throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。
使用格式：throw new 异常类名(参数);
2、声明异常throws
声明异常：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理（稍后讲
解该方式），那么必须通过throws进行声明，让调用者去处理。
关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).
声明异常格式：修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{ }
3、try...catch...finally
三、自定义异常
四、多线程
1、并发与并行
并发：指两个或多个事件在同一个时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）。
2、进程与线程
3、创建线程类
创建线程的方式一：
4、多线程原理
创建线程的两种方式：
1）继承Thread类
2）实现Runnable接口
4.1 Thread类
构造方法：
public Thread() :分配一个新的线程对象。
public Thread(String name) :分配一个指定名字的新的线程对象。
public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。
常用方法：
public String getName() :获取当前线程名称。
public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
public void run() :此线程要执行的任务在此处定义代码。
public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
public static Thread currentThread() :返回对当前正在执行的线程对象的引用。
翻阅API后得知创建线程的方式总共有两种，一种是继承Thread类方式，一种是实现Runnable接口方式
创建线程的方式二：
采用 java.lang.Runnable 也是非常常见的一种，我们只需要重写run方法即可。
步骤如下：
1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正
的线程对象。
3. 调用线程对象的start()方法来启动线程。
public class TestRun {
public static void main(String[] args) {
//创建自定义的线程对象
MyRunnable myRun= new MyRunnable();
Thread t = new Thread(myRun,"接口创建线程");
t.start();
for (int i = 0; i < 10; i++) {
System.out.println("main"+i);
}
}
}
public class MyRunnable implements Runnable{
public void run() {
for (int i = 0; i <10 ; i++) {
System.out.println(Thread.currentThread().getName()+ i);
}
}
}4.2Thread 和Runnable的区别
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
总结：
实现Runnable接口比继承Thread类所具有的优势：
1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
扩充：在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用
java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进
程。
4.3 匿名内部类方式实现线程的创建
使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。
使用匿名内部类的方式实现Runnable接口，重写Runnable接口中的run方法：
package com.dzg.thread;
public class NoNameInnerClassThread {
public static void main(String[] args) {
Runnable r = new Runnable() {
public void run() {
for (int i = 0; i < 7; i++) {
System.out.println("利拉德"+ i );
}
}
};
new Thread(r).start();
for (int i = 0; i < 7; i++) {
System.out.println("马科勒姆" + i);
}
}
}
五、线程安全
线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写
操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，
否则的话就可能影响线程安全。
1、线程同步
那么怎么去使用呢？有三种方式完成同步操作：
1 . 同步代码块。
2. 同步方法。
3. 锁机制。
1）同步代码块
2）同步方法
3）Lock锁机制
package com.dzg.thread.safe;
public class TestSafe {
public static void main(String[] args) {
SaleTicket st = new SaleTicket();
Thread t1 = new Thread(st,"窗口1");
Thread t2 = new Thread(st,"窗口2");
Thread t3 = new Thread(st,"窗口3");
t1.start();
t2.start();
t3.start();
}
}
package com.dzg.thread.safe;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SaleTicket implements Runnable{
private int ticket = 100;
/*
线程不安全
public void run() {
while(true){
if(ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
String name = Thread.currentThread().getName();
System.out.println(name +"正在销售票"+ ticket--);
}
}
}*/
/* //添加同步代码块
Object lock = new Object();
public void run() {
synchronized(lock){//lock为同步锁
while(true){
if(ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
String name = Thread.currentThread().getName();
System.out.println(name +"正在销售票"+ ticket--);
}
}
}
}*/
//使用同步方法
/*public void run() {
while(true){
sellTicket();
}
}
public synchronized void sellTicket(){
if(ticket > 0){
try {
Thread.sleep(30);
} catch (InterruptedException e) {
e.printStackTrace();
}
String name = Thread.currentThread().getName();
System.out.println(name+"正在销售票"+ ticket--);
}
}*/
//加Lock锁的方式
Lock lock = new ReentrantLock();
public void run(){
/**
* 每个窗口的买票操作
* 窗口永远开启
*/
while(true){
lock.lock();
if (ticket > 0){
try {
Thread.sleep(70);
} catch (InterruptedException e) {
e.printStackTrace();
}
String name = Thread.currentThread().getName();
System.out.println(name+" 正在销售票： "+ ticket--);
}
lock.unlock();
}
}
}
六、线程的状态
1、线程状态概述
1）Timed Waiting （计时等待）
public class TestTimeWaiting extends Thread{
public void run(){
for (int i = 0; i < 100; i++) {
if(i % 10 == 0){
System.out.println("========= "+i);
}
System.out.println(i);
try {
Thread.sleep(1000);
System.out.println("线程睡眠一秒");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
new TestTimeWaiting().start();
}
}
2） BLOCKED （锁阻塞）
3）Waiting （无限等待）
Wating状态在API中介绍为：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。
public class TestWaiting {
public static Object obj = new Object();
public static void main(String[] args) {
//演示waiting
new Thread(new Runnable() {
public void run() {
while(true){
synchronized(obj){
try {
System.out.println(Thread.currentThread().getName()+"===获取到锁对象" +
"调用wait方法，进入waiting状态，释放锁对象===");
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"===从waiting状态醒来，" +
"获取到锁对象，继续执行了===");
}
}
}
},"等待线程").start();
new Thread(new Runnable() {
public void run() {
//while(true){
try {
System.out.println(Thread.currentThread().getName()+"------等待三秒");
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (obj){
System.out.println(Thread.currentThread().getName()+"-------获取到" +
"锁对象，调用notify方法，释放锁对象");
obj.notify();
}
// }
}
},"唤醒线程").start();
}
}
七、线程池
1、线程池概念
线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，
无需反复创建线程而消耗过多资源。
线程池工作原理：
2、线程池的使用
Java里面线程池的顶级接口是 java.util.concurrent.Executor ，但是严格意义上讲 Executor 并不是一个线程
池，而只是一个执行线程的工具。真正的线程池接口是 java.util.concurrent.ExecutorService 。
要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优
的，因此在 java.util.concurrent.Executors 线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官
方建议使用Executors工程类来创建线程池对象。
Executors类中有个创建线程池的方法如下：
public static ExecutorService newFixedThreadPool(int nThreads) ：返回线程池对象。(创建的是有界线
程池,也就是池中的线程个数可以指定最大数量)
获取到了一个线程池ExecutorService 对象，那么怎么使用呢，在这里定义了一个使用线程池对象的方法如下：
public Future<?> submit(Runnable task) :获取线程池中的某一个线程对象，并执行
其中Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用。
使用线程池中线程对象的步骤：
1. 创建线程池对象。
2. 创建Runnable接口子类对象。(task)
3. 提交Runnable接口子类对象。(take task)
4. 关闭线程池(一般不做)。
//RUnnbale实现类
public class MyRunable implements Runnable{
public void run() {
System.out.println("我要一个教练");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("教练： "+Thread.currentThread().getName()+"来了");
System.out.println("教我游泳，教完后，教练回到了游泳池！");
}
}
//测试线程池的使用
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestThreadPool {
public static void main(String[] args) {
//创建线程池对象
ExecutorService service = Executors.newFixedThreadPool(100);//包含2个线程对象
//创建Runnable的实例对象
MyRunable mr = new MyRunable();
/**
* 自己创建线程对象的方式
*/
/*Thread thread = new Thread(mr);
thread.start();*/
//从线程池中获取线程对象，然后调用MyRunbale中的run()
service.submit(mr);
//在获取两个线程对象，调用MyRunbale中的run()
service.submit(mr);
service.submit(mr);
/**
* 注意，service方法结束后，程序并不终止，是因为线程池控制了线程的关闭
* 将使用完的线程有归还到线程池中
*
* 关闭线程池
*/
//service.shutdown();
}
}
362
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
