1.异常
1.1 异常处理
Scanner input = new Scanner(System.in);
try {
System.out.print("被除数：");
int num1 = input.nextInt();
System.out.print("除数：");
int num2 = input.nextInt();
System.out.println(num1/num2);
}catch(InputMismatchException e){
//整数
System.out.println("请输入整数");
//return;//还会执行finally
}catch(ArithmeticException e){
System.out.println("除数不能为零");
//System.exit(0);//不会执行finally
}catch(Exception e) {
//所有异常
System.out.println("异常");
}finally{
//最终执行的代码
System.out.println("finally");
}
//多重catch子类在前父类在后
//finally:无论如何都会执行的代码,
//---可靠的资源释放---连接
//return 会让finally执行,return是结束当前方法，
//其他方法继续执行，需要释放其他资源
//System.exit(0)：退出虚拟机，所有方法都不执行，没有资源可以释放
throws //声明异常
//final finally finalize
//先把异常捕获，然后抛出异常---业务异常
//异常
try,catch,finally,throw,throws
执行正常代码，捕获异常，释放资源，抛出异常，声明异常1.2自定义异常
//类方法
public class UserEcp extends UserException{
private String message;
//名字为message可以异常输出，继承了父类
/**
父类方法
public String toString() {
String s = getClass().getName();
String message = getLocalizedMessage();
return (message != null) ? (s + ": " + message) : s;
}
*/
public UserEcp(String message) {
super();
this.message = message;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
}
//执行代码
public class TestSex {
public static void main(String[] args) {
try {
ecp();
} catch (UserEcp e) {
e.printStackTrace();
//System.out.println(e.getMessage());
}
System.out.println("结束");
}
public static void ecp() throws UserEcp{
Scanner input = new Scanner(System.in);
System.out.println("请输入性别：");
char gender = input.next().charAt(0);
if(gender=='男'||gender=='女') {
Student s = new Student("coco", gender);
System.out.println(s.toString());
}else {
throw new UserEcp("请输入正确的性别");
}
}
}2.多线程
2.1进程和线程
进程：
独立的应用程序，有独立内存空间
线程：
一个进程多个线程组合在一起
Thread main = Thread.currentThread();//当前线程
main.setName("主线程");
System.out.println(main.getId());//线程编号
System.out.println(main.getName());//线程名字
main.setPriority(Thread.MAX_PRIORITY);//1-10 优先级范围是1-10，默认是5
System.out.println(main.getPriority());//线程优先级
//main.setDaemon(false);//自己创建的其他线程可以设为守护线程，但是线程不可以
System.out.println(main.getState());//线程状态--RUNNABLE
System.out.println(main.isAlive());//线程是否还活着
System.out.println(main.isDaemon());//是否是守护线程
System.out.println(main.hashCode());//hashcode
//注意这个不是单线程程序，只能说只有一个主线程，还有很多守护线程
while(true) {
}2.2 为什么要编写多线程
1.让cpu更好的工作
2.多线程可以简化编程模型2.3 如何编写多线程程序
创建线程四种方案：
继承类
public class MyThread extends Thread{
public void run() {
for(int i=1;i<10;i++) {
System.out.println(Thread.currentThread()+"线程----"+i);
}
}
}
//
public class TestMythread {
public static void main(String[] args) {
MyThread m1 = new MyThread();
MyThread m2 = new MyThread();
m1.start();
m2.start();
}
}
实现Runnable接口
public class MyThread implements Runnable{
public void run() {
for(int i=1;i<10;i++) {
System.out.println(Thread.currentThread()+"线程----"+i);
}
}
}
继承Thread
public class TestMythread {
public static void main(String[] args) {
MyThread mth = new MyThread();
Thread th = new Thread(mth);
th.start();
}
}2.4线程的生命周期
1.阻塞之后不是进到运行状态，而是就绪状态，等资源
2.一个线程只能start一次，启动之后只能等消失
2.5线程调度
1.setPriority(1-10)通过设值来设置线程执行概率
2.Thread.sleep():线程休眠
3.线程礼让：Thread.yeild()
4.线程加入：th.join() :让这个线程执行完再执行被阻塞的线程
5.线程中断：
public class MyThread extends Thread{
public void run() {
//任务是死循环，不断检测中断信号，别人发中断信号了，我们就结束循环
while(true) {
if(this.isInterrupted()==true) {//检测中断信号
break;
}
}
}
}
public class Test {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
MyThread th = new MyThread();
th.start();
System.out.println("是否中断？y/n");
char choice = input.next().charAt(0);
if(choice=='y') {
//调用线程中断的代码
th.interrupt();//中断线程---不能改变线程目前运行状态，只能改变线程的一个中断标记
}
}
}
守护线程：
如果不是守护线程，run方法要执行完才能退出虚拟机
是守护线程，其余的非守护线程执行完毕之后就会退出虚拟机
serDaemon(true):设置线程为守护线程2.6 Callable
1.计算一个包含一万个元素数组，多线程并行计算数组元素的和
方案一 Runnable
缺陷：无返回值，不能抛异常
//任务类
public class ArrayThread implements Runnable{
int[] nums;
int sum = 0;
public void run() {
for(int i=0;i<nums.length;i++) {
sum += nums[i];
}
}
//构造方法来接收任务数组
public ArrayThread(int[] nums) {
super();
this.nums = nums;
}
}
//循环计算，创建十个线程
public class Test2 {
public static void main(String[] args) throws InterruptedException {
int[] nums = new int[10000];
for (int i = 0; i < nums.length; i++) {
nums[i] = i + 1;// 1-10000-----50005000
}
int sum =0;
int count= 10;
Map<Thread, ArrayThread> map = new HashMap<Thread, ArrayThread>();
for(int i=0;i<count;i++) {
int[] num =new int[nums.length/count];
for(int j=0;j<num.length;j++) {
num[j]=nums[j+nums.length/count*i];
}
ArrayThread st = new ArrayThread(num);
Thread th = new Thread(st);
th.start();//启动会自动计算第i个数组的结果
map.put(th,st);
}
for(Thread th:map.keySet()) {
th.join();//效率取决与最慢的线程
sum+=map.get(th).sum;
}
System.out.println(sum);
}
}方案二 Callable
//类方法
public class ArrayThread2 implements Callable<Integer>{
int[] nums;
public Integer call() {
int sum = 0;
for(int i=0;i<nums.length;i++) {
sum += nums[i];
}
return sum;
}
public ArrayThread2(int[] nums) {
super();
this.nums = nums;
}
public ArrayThread2() {
}
}
//计算
public class Test2 {
public static void main(String[] args) throws InterruptedException, ExecutionException {
int[] nums = new int[10000];
for (int i = 0; i < nums.length; i++) {
nums[i] = i + 1;// 1-10000-----50005000
}
int sum =0;
int count= 10;
List<FutureTask> fts = new ArrayList<FutureTask>();
for(int i=0;i<count;i++) {
//分配任务
int[] num =new int[nums.length/count];
for(int j=0;j<num.length;j++) {
num[j]=nums[j+nums.length/count*i];
}
ArrayThread2 st = new ArrayThread2(num);
//把Callable伪装成Runnable
FutureTask<Integer> ft = new FutureTask<Integer>(st);
Thread th = new Thread(ft);
th.start();
fts.add(ft);
}
for(FutureTask<Integer> ft:fts) {
sum+=ft.get(); //算完一个给一个，等到call方法执行
}
System.out.println(sum);
}
}2.7 线程安全
铁道部发布了一个售票任务，要求销售1000张票，要求有3个窗口来进行销售，请编写多线程程序来模拟这个卖票效果
i. 窗口001正在销售第1000张票
ii. 窗口001正在销售第999张票
iii. 窗口002正在销售第998张票
iv. 。。。
v. 窗口002正在销售第1张票
vi. 票已经销售完毕
线程任务：
总票数-1，编号+1，窗口不断卖票
使用同步代码块
synchronized加锁
//方法类一
public class SaleTicke implements Runnable{
private String name;
int num = 10;
int count =0;
@Override
public void run() {
while(true) {
synchronized (this) {
if (num <= 0) {
System.out.println(Thread.currentThread().getName()+"售罄");
break;
}
num--;
count++;
System.out.println(Thread.currentThread().getName()+"正在销售第"+count+"张票，还剩"+num+"张");
}
}
}
}
//方法类二，同步方法
public class SaleMethods implements Runnable{
private String name;
int num = 10;
int count =0;
boolean flag = true;
@Override
public void run() {
while(flag) {
sale();
}
}
public synchronized void sale() {
synchronized (this) {
if (num <= 0) {
System.out.println(Thread.currentThread().getName()+"售罄");
flag = false;
return;
}
num--;
count++;
System.out.println(Thread.currentThread().getName()+"正在销售第"+count+"张票，还剩"+num+"张");
}
}
}
//执行方法
public class Test {
public static void main(String[] args) {
SaleTicke st = new SaleTicke();
// SaleMethods st = new SaleMethods();
Thread th1 = new Thread(st,"窗口001");
Thread th2 = new Thread(st,"窗口002");
Thread th3 = new Thread(st,"窗口003");
th1.start();
th2.start();
th3.start();
}
}
Lock加锁会导致效率降低2.8 线程不安全
2.8.1 懒汉单例不安全
//懒汉单例模式
public class Student {
private Student() {}
//private static Student s=new Student();//饿汉模式，同一个对象
private static Student s = null;
public static Student getInstance() {
if(s==null) {
s = new Student();
}
return s;
}
}
public static void main(String[] args) {
for(int i=1;i<=3;i++) {
new Thread(new Runnable() {
public void run() {
System.out.println(Student.getInstance());
}
}).start();
}
}2.8.2 ArrayList是线程不安全的
public class TestArrayList {
public static void main(String[] args) throws InterruptedException {
ArrayList<String> list = new ArrayList<>();
Thread th1 = new Thread(new Runnable() {
public void run() {
list.add("a");
}
});
Thread th2 = new Thread(new Runnable() {
public void run() {
list.add("b");
}
});
Thread th3 = new Thread(new Runnable() {
public void run() {
list.add("c");
}
});
th1.start();
th2.start();
th3.start();
th1.join();
th2.join();
th3.join();
System.out.println(list);
}
}
会出现以下情况：
[b,a] [a,c],[null, c, a] [null,c] [null,null,c] [b] ...
//
Vector保证线程安全是通过所有代码都加synchronized
CopyOnWriteArrayList：线程安全的类，集合需要高并发
Hashtable---synchronized
HashMap---为同步---不安全
ConcurrentHashMap---安全2.9 死锁
死锁：当线程需要多个资源的时候，一个线程获取到一部分资源，另外一个线程获取到另外一部分资源，这时候就会产生死锁
案例：
//类方法
public class Dead implements Runnable{
//设计两个资源
Integer a;//第一把锁
Integer b;//第二把锁
public Dead(Integer a,Integer b) {
this.a = a;
this.b = b;
}
public void run() {
synchronized (a) {
System.out.println(Thread.currentThread().getName()+"获取到"+a);
synchronized (b) {
System.out.println(Thread.currentThread().getName()+"获取到"+b);
System.out.println(a+"+"+b+"="+(a+b));
}
}
}
}
//执行方法
public class TestDead {
public static void main(String[] args) {
Dead d1 = new Dead(1,2);//a=1,b=2
Dead d2 = new Dead(2,1);//a=2,b=1
new Thread(d1,"线程1").start();
new Thread(d2,"线程2").start();
}
}2.10 线程池
2.10.1 池的概念
线程池：装线程的池子
连接池：装连接的
为什么需要线程池：
线程最大的缺点就是：开启之后运行完就没了2.10.2 自定义线程池的原理
自定义线程池
Executor
ThreadPoolExecutor
int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue
/*
int corePoolSize,--------核心线程个数
int maximumPoolSize,-----最大线程个数
long keepAliveTime,------保持存活时间
TimeUnit unit,-----------时间单位
BlockingQueue<Runnable> workQueue---工作队列--任务队列
*/
ThreadPoolExecutor pool = new ThreadPoolExecutor(5, 10, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(4));
pool.execute(new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName()+"--执行任务");
}
});TreadFactory2.10.3 自动创建线程池
1、ExecutorService pool = Executors.newSingleThreadExecutor();//创建一个单线程的线程池
new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>())
//特点：只有一个线程，队列无限大
public class TestPool2 {
public static void main(String[] args) {
ExecutorService pool = Executors.newSingleThreadExecutor();//创建一个单线程的线程池
//队列无限大，当任务很多，队列一直放，就会导致内存溢出
for (int i = 0; i < Integer.MAX_VALUE; i++) {
int temp = i;
pool.execute(new Runnable() {
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"--"+temp);
}
});
}
}
}
2.ExecutorService pool = Executors.newFixedThreadPool(10);//创建一个单线程的线程池
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
//特点：核心线程=最大线程=n,队列无线
public class TestFix {
public static void main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(10);//创建一个单线程的线程池
for (int i = 1; i <=1000; i++) {
int temp = i;
pool.execute(new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName()+"----"+temp);
}
});
}
}
}
3、ExecutorService pool = Executors.newCachedThreadPool();
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
//特点：核心线程为0，最大线程无线，60s回收无任务的线程，队列是同步队列（自身没有缓存功能）
public class TestCached {
public static void main(String[] args) {
ExecutorService pool = Executors.newCachedThreadPool();//
for (int i = 1; i <=1000; i++) {
int temp = i;
pool.execute(new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName()+"----"+temp);
}
});
}
}
}
4、定时执行的线程池
public class TestSchedule {
public static void main(String[] args) {
ScheduledExecutorService pool = Executors.newScheduledThreadPool(10);
//后台定时器--以固定的频率
pool.scheduleAtFixedRate(new Runnable() {
public void run() {
System.out.println("重复执行的代码");
}
}, 2, 1, TimeUnit.SECONDS);//第一次等两秒，后面每秒执行run里面的代码
}
}
/**
* 核心线程和最大线程指定，队列是可以按照任务等待时间排序，可以实现任务的循环调用
* @author Administrator
*
*/2.10.4 源码分析
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/*
* Proceed in 3 steps:
*
* 1. If fewer than corePoolSize threads are running, try to
* start a new thread with the given command as its first
* task. The call to addWorker atomically checks runState and
* workerCount, and so prevents false alarms that would add
* threads when it shouldn't, by returning false.
*
* 2. If a task can be successfully queued, then we still need
* to double-check whether we should have added a thread
* (because existing ones died since last checking) or that
* the pool shut down since entry into this method. So we
* recheck state and if necessary roll back the enqueuing if
* stopped, or start a new thread if there are none.
*
* 3. If we cannot queue task, then we try to add a new
* thread. If it fails, we know we are shut down or saturated
* and so reject the task.
*/
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))//true代表核心线程以内
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);//false代表超过核心线程
}
else if (!addWorker(command, false))//开最大线程失败
reject(command);
}
核心点:
会new线程池,同时知道这些参数之间的关系2.11 ThreadLocal
1-1000个时间需要输出来：一个时间需要单独用一个线程来完成输出。
/**
* 第一种方式
* @author Administrator
*
*/
public class Test {
public static void main(String[] args) {
for (int i = 1; i <=1000; i++) {
int temp = i;
new Thread(new Runnable() {
public void run() {
Date date = new Date(temp*1000);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(sdf.format(date));
}
}).start();
}
}
}
/**
* 第二种：使用线程池来解决线程的开闭和开销
* @author Administrator
*
*/
public class Test1 {
public static void main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(10);
for (int i = 1; i <=1000; i++) {
int temp =i;
pool.execute(new Runnable() {
public void run() {
Date date = new Date(temp*1000);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(Thread.currentThread().getName()+"--"+sdf.format(date));
}
});
}
pool.shutdown();
}
}
/**
* 第三种：把格式化的过程放到工具类中
* 问题sdf创建的太多了
* @author Administrator
*
*/
public class Test2 {
public static void main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(10);
for (int i =1; i <=1000; i++) {
int temp =i;
pool.execute(new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName()+"--"+DateUtil.getDate(temp));
}
});
}
pool.shutdown();
}
}
class DateUtil{
public static String getDate(int i) {
Date date = new Date(i*1000);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
return sdf.format(date);
}
}
/**
* 第四种
* 把sdf设计为一个对象
* @author Administrator
*问题：线程不安全
*一个类如果没有成员变量，这个类一定是安全的
*做成成员变量就被所有的线程所共享，因此就不安全
*/
public class DateUtil2 {
private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
public static String getDate(int i) {
Date date = new Date(i*1000);
return sdf.format(date);
}
}
/**
* 第五种：加锁
* 加锁实现了安全
* 问题： 所有的线程所有任务都会在格式化这行代码阻塞，效率会受到影响
* @author Administrator
*
*/
public class DateUtil3 {
private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
public static String getDate(int i) {
Date date = new Date(i*1000);
String str=null;
synchronized (DateUtil3.class) {
str = sdf.format(date);
}
return str;
}
}
/**
* 第六种：使用ThreadLocal来做线程隔离，每个线程设置一个SimpleDateFormat
* @author Administrator
*
*/
public class DateUtil4 {
// private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
static ThreadLocal<SimpleDateFormat> tl = new ThreadLocal<SimpleDateFormat>() {
protected SimpleDateFormat initialValue() {
return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
}
};//创建一个匿名内部类
public static String getDate(int i) {
Date date = new Date(i*1000);
String str=null;
str = tl.get().format(date);
System.out.println(Thread.currentThread().getName()+"--"+System.identityHashCode(tl.get()));
return str;
}
}2.12 ThreadLocal源码分析
public T get() {
//每个线程执行get方法的时候获取线程对象
Thread t = Thread.currentThread();//获取当前线程对象----
//获取ThreadLocalMap对象---入参是当前对象--根据当前线程获取一个map
ThreadLocalMap map = getMap(t);
if (map != null) {
//如果这个map里面有值，就从map中取给你
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
//另外的渠道给你
return setInitialValue();
}
getMap(t):
ThreadLocalMap getMap(Thread t) {
//Thread类：
//ThreadLocal.ThreadLocalMap threadLocals = null;
return t.threadLocals;//t-当前线程 threadLocals:ThreadLocalMap类型的成员变量
}
//setInitialValue
private T setInitialValue() {
//这个方法是我们在new ThreadLocal对象的时候用了一个匿名内部类重写他
//第一次map里面没有这个值的这个时候会调用这个这个方法，如果后面这个线程再来获取
//会直接从map里面给他
T value = initialValue();//调到我们重写的方法---sdf
Thread t = Thread.currentThread();//获取当前线程
ThreadLocalMap map = getMap(t);//获取线程里面的map集合
if (map != null) {
map.set(this, value);//map已经有了，一定是已经放了其他的tl对象进去
} else {
createMap(t, value);//创建一个ThreadLocalMap threadLocals
}
if (this instanceof TerminatingThreadLocal) {
TerminatingThreadLocal.register((TerminatingThreadLocal<?>) this);
}
return value;
}
void createMap(Thread t, T firstValue) {
//当前线程的map集合在这里创建---键是ThreadLocal对象，值是sdf
t.threadLocals = new ThreadLocalMap(this, firstValue);//this tl
}
set方法：修改ThreadLocal里面的值
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
map.set(this, value);
} else {
createMap(t, value);
}
}
remove方法：删除键值对
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null) {
m.remove(this);
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
