java多线程复习转载

1 .finally 语句：这个代码块中定义的是一定会执行的代码。

不能被catch块中的return语句结束，可是能被System.exit(0)结束。

2.主要用于关闭资源，只要使用了资源，就一定要将其关闭。

3.应用：数据库的连接，连接——操作——关闭。可能在操作过程中出现异常，没关闭数据库，就需要把关闭数据库放在finally语句里面。
2 组合方式：

try{}catch (){}、try{}catch(){}、try{}finally{}(这种用于关闭资源)

3 .异常在覆盖时的细节

1.子类在覆盖父类方法时，如果父类方法抛出了异常，子类覆盖的方法只能抛出父类方法异常或其子类。
2.父类方法如果抛出多个异常，子类在覆盖父类方法时，只能抛出父类异常的子集。
3.如果父类中的方法没有抛出异常，子类覆盖父类时，绝对不能声明异常。只能进行 try{} catch 处理；如果处理不了，那就应该让程序

停掉，让调用者知道。即在catch中抛出RuntimeException异常或其子类对象，这时不用抛，RuntimeException不用在函数上声明。

包(package)：包名具有唯一性 在windows中的具体体现：文件夹。

包的作用：1.分类管理类文件；

2.对类提供了多层名称空间。

2.如何定义：使用关键字 package,定义必须定义在源代码的第一行，类名的全称是：包名.类名；

包名全小写如mypackage.

3.步骤：1.javac -d 包的路径 全类名.java

2.set classpath=包的路径；

3.java 包名.类名
一个包中不能存在两个public修饰的类。

被访问的包中，类和方法都需要被public修饰，否则权限不够。

4.包与包之间的继承

protected:包的修饰符，保护权限，只有子类才能用；用于保护父类中的成员。

四种权限： public protected default(默认的) private

同一个类中： ok ok ok ok

同一个包中： ok ok ok

子类： ok ok

不同包中： ok

5.简化书写：使用import关键字导入，格式：import 全类名；导入的都是包中的类；若是需要导入多个类，则使用通配符，如 import packa.*。而在真实开发时，用到哪个则导入哪个，根本也用不到导入，用高级编辑器。

6.注意：

1.import packa.* ：只导入packa包的当前目录下的所有类，而不导入当前目录下的包。

2.当导入的包中的类有重名时，使用该类时，必须用包名.类名的全名称，否则无法区分，会产生使用的不确定性。

如 import packa.Demo;

import packb.Demo;

不能new Demo(),而需new packa.Demo();

5 Jar包：java的压缩包。

-c:创建新的归档文件

-x:解压

java压缩工具：jar cvf haha.jar pack

6 多线程技术

1.进程：正在进行中的程序。

2.线程(Thread)：负责进程进行执行。一个进程至少有一个线程，若有多个则称为多线程程序；线程也可以称为执行线程、执行路径、执行背景。

3.好处：可以同时执行多个程序。

4.JVM多线程的基本体现：

JVM也是多线程，至少有一个主线程和垃圾回收线程。主线程执行的是主函数中的内容，垃圾回收线程执行的对堆内存进行内存释放的代码。

5.垃圾回收的方法：finalize(),垃圾回收

gc()：运行垃圾回收器,System.gc();启动后不一定立即执行，因为CPU在随机做着切换，先切换到哪就先执行哪个。

6.自定义线程：通过APIThread类的查阅，两种方式：

1.继承Thread类，覆写run()方法，创建Thread子类对象，调用start方法来开启线程并调用run方法；线程类在描述线程时，有一个功能函数run，专门用于封装执行的任务
。

主线程也是同理，该线程执行的任务在主函数中。

Thread t=new Thread();创建进程。

1.覆写run方法的原因：创建进程的目的是为了运行指定的代码，任务就应该自己指定。

2.特定方法start():开启线程并调用run方法运行线程。

start和run区别：调用run方法，并没有开启新的线程，都是由主线程来执行，无法完成同时运行的需求；

调用start方法，开启了新的线程并调用了线程的任务方法run方法，实现了代码同时执行。

3.执行路径是在每一条路径上先进后出的，即每个线程都有自己单独的一片栈内存空间。

4.currentThread():返回当前正在执行的进程，Thread.currentThread().getName();结果是Thread-编号，编号从0开始。
5.线程是分区来进行管理的，当前线程发生异常只影响当前线程，不影响其它线程。

6.主线程是最后结束的线程，只要还有存活的线程，它就不能结束。

第二种:实现Runnable接口，见第十二天日志

创建线程的目的：为了开辟一个执行路径去执行指定的代码，让其和其它代码同时运行；意味着每一个线程的创建都有自己要运行的内容，而这个内容也称为线程的任务。

线程的四种状态：被创建、运行、冻结notify、sleep、wait、消亡(还有一个特殊状态：就绪)

被创建：start();

运行：具备执行资格，同时具备执行权

冻结：sleep(time), wait()---notify()唤醒；线程释放了执行权，同时释放资格。

临时阻塞状态：线程具备CPU的执行资格，没有CPU的执行权

消亡：stop()
 

创建线程的第一种方式是：
1，继承Thread，//** extends Thread

2，复写run方法，将线程要运行的任务代码存储到run方法中。//public void run(){}

3，创建Thread类的子类对象。Ticket t = new Ticket(); Thead t1 = new Thread()

4，调用start方法开启线程并调用run方法。t1.start()

创建线程的第二种

1，定义类实现Runnable接口

2. 覆盖该接口中的run（）方法

3，通过Thread类创建线程对象，

4，将实现Runnable接口的实现类的对象作为参数传递给Thread类的构造函数

将run方法所属的对象传递给线程，让线程去运行指定的对象 的run 方法。

5，调用Thread类的start 方法开启线程

Runnable接口的好处：

避免了单继承的局限性

Runnable接口的出现 ，更是按照面向对象的思想，将线程要运行的任务进行单独的封装，

降低了线程对象和线程任务的耦合性。

class Demo extends Thread{//第一种

public viod run(){}

}
Demo d1 = new Demo();

Demo d2 = new Demo();//线程对象和线程的耦合性强
//将线程任务进行描述

class Demo implements Runnable{//第二种

public void run(){}

}
class Demo2 implements Runable{

public void run(){

}

}
Demo d = new Demo();//将线程任务封闭成对象
Demo2 d2 = new Demo2();

Thread t = new Thread(d2);//通过线程对象的构造函数和任务相关联
创建线程，建议使用第二种方式。
class Demo implements Runnable{

//将线程要运行的任务代码封装到了run方法中

public void run(){

for(int x=1; x<=20; x++){

System.out.println(Thread.currentThread().getName()+"..."+x);

}

}

}
class ThreadDemo4{

public static void main(String args[]){

Demo d=new Demo();
//创建线程对象。因为没有了Thread的子类 ，所以通过Thread类来完成线程对象的创建。

Thread t1=new Thread(d);

Thread t2=new Thread(d);

t1.start();//开启了线程并调用了线程中的run方法。只不过线程类中的run方法并没有定义我们要让线程运行的内容。

t2.start();

}

}
第一种方式

class Demo extends Thread{

//覆盖Thread类中的run方法，将线程任务代码封装到该方法中。

public void run(){

for(int x=1; x<=20; x++){

System.out.println(Thread.currentThread().getName()+"...extends..."+x;

}

}

}

创建线程，建议使用第二种方法

多线程的安全问题
对安全问题的分析：

1，多个线程在处理同一个共享数据

2， 线程任务代码中有多条语句在操作这个共享数据

3，这些多条操作共享数据的语句被多个线程分开进行执行

也就是说，在一个线程执行这些语句的过程中，其它线程参与了运算，导致数据的错误
总结： 线程任务代码中只要存在着：

1，共享数据

2 多条操作共享数据的语句

就容易产生多线程的安全问题

解决线程安全问题的原理：

将多条操作共享数据代码进行封装，

在某一时刻，只能一个线程在内运行，在运行期间，其它的线程都进不来

只有这个线程运行完，其它线程才有机会执行其中的内容

怎样封装呢？

JAVA中提供了一个用于封闭的代码块，就是同步代码块

synchronized(obj)//这个obj对象可以是任意的

{

}
synchronized synchronized//相当于一个锁 举例：火车上的卫生间

为了给同步代码块指定一个对象，可以用自定义的，也可以用已有的

如object

同步的好处：解决了多线程的安全问题
当程序中出现了多线程的安全问题时，加入了同步进行解决，却发现问题依旧，

你可以先明确一下同步的前提
同步的前提：

必须有多个线程，而且使用的是同一个锁。

同步的弊端：降低了效率。容易出现死锁

class Ticket implements Runnable{

private int num = 100;

private Object obj = new Object();

public void run(){

while(true){

synchronized(obj){

if (num>0)

try{Thread.sleep(10)}

catch(InterruptedException e){

e.getMessage()}//让线程在这里小睡一下

System.out.println(Thread.currentThread().getName()+"..."+num--);

}

}

}

}

class TicketDemo2{

public static void main(String args){

Ticket t = new Ticet();

Thread t1 = new Thread(t);

Thread t2 = new Thread(t);

Thread t3 = new Thread(t);

Thread t4 = new Thread(t);

t1.start();

t2.start();

t3.start();

t4.strt();

}

}