黑马程序员——JAVA学习笔记——多线程

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

多线程
相关的基本概念：

进程与线程的区别：

进程是程序的一次动态执行过程，需要经历从代码加载、代码执行到执行完毕的一个完整过程，这个过程也是进程本身从产生、发展到最终消亡的过程。

多线程是实现并发机制的一种有效手段。

线程是比进程更小的执行单位，线程是在进程的基础之上进行的进一步划分。所谓的多线程是指一个进程在执行过程中可以产生多个更小的程序单元，这些更小的单元成为线程，这些线程可以同时存在、同时运行，一个进程可能包含了多个同时执行的线程。

线程的两种创建方法：

1、 继承Thread 类，由子类复写run()方法；

2、 Interface Runnable 接口,复写run()方法；

A. 继承Thread:

步骤：1、定义类继承Thread类；

2、目的是复写run方法，将要让线程运行的代码都存储到run方法中；

3、通过创建Thread类的子类对象，创建线程 对象；

4、调用线程的start方法，开启线程，并执行run方法。

样板代码：

classMyThread extends Thread{ // 继承Thread类，作为线程的实现类

private int ticket = 5 ; // 表示一共有5张票

public void run(){ // 覆写run()方法，作为线程 的操作主体

for(int i=0;i<100;i++){

if(this.ticket>0){

System.out.println("卖票：ticket = " +ticket--) ;

}

}

}

};

publicclass Test{

public static void main(String args[]){

MyThread mt1 = new MyThread() ; // 实例化对象

MyThread mt2 = new MyThread() ; // 实例化对象

MyThread mt3 = new MyThread() ; // 实例化对象

mt1.run() ; // 调用线程主体

mt2.run() ; // 调用线程主体

mt3.run() ; // 调用线程主体

}

};



B、实现一个接口Runnable。

步骤：

1、定义类实现Runnable接口。

2、覆盖接口中的run方法（用于封装线程要运行的代码）。

3、通过Thread类创建线程对象；

4、将实现了Runnable接口的子类对象作为实际参数传递给Thread类中的构造函数。 为什么要传递呢？因为要让线程 对象明确要运行的run方法所属的对象。

5、调用Thread对象的start方法。开启线程，并运行Runnable接口子类中的run方法。

Ticket t = new Ticket();

直接创建Ticket对象，并不是创建线程对象。

因为创建对象只能通过new Thread类，或者new Thread类的子类才可以。

所以最终想要创建线程。既然没有了Thread类的子类，就只能用Thread类。

只要将t作为Thread类的构造函数的实际参数传入即可完成线程对象和t之间的关联

为什么要将t传给Thread类的构造函数呢？其实就是为了明确线程要运行的代码run方法。

样板代码：

classMyThread implements Runnable{ // 继承Thread类，作为线程的实现类

private int ticket = 5 ; // 表示一共有5张票

public void run(){ // 覆写run()方法，作为线程 的操作主体

for(int i=0;i<100;i++){

if(this.ticket>0){

System.out.println("卖票：ticket = " +ticket--) ;

}

}

}

};

publicclass Test{

public static void main(String args[]){

MyThread mt = new MyThread() ; // 实例化对象

new Thread(mt).run() ; // 调用线程主体

new Thread(mt).run() ; // 调用线程主体

new Thread(mt).run() ; // 调用线程主体

}

};



由以上两段代码运行结果可以看出：

实现Runnable接口相对于继承Thread类来说，有如下显著的优势：

1、 适合多个相同程序代码的线程去处理统一资源的情况。

2、 可以避免由于JAVA的单继承特性带来的局限。

3、 增强了程序的健壮性，代码能够被多个线程共享，代码与数据是独立的

线程状态：

任何线程一般具有5种状态



新建：用构造方法创建一个线程对象后，Threadthread=new Thread();

就绪：调用该线程的start()f方法就可以启动线程。启动后进入就绪状态。

运行：sleep(time),wait()—notify()唤醒，suspend()；线程释放了执行权，同时释放执行资格；

阻塞：线程具备cpu的执行资格，没有cpu的执行权；

消亡：stop() 或run()方法执行结束后。

样板代码:

class MyThread implementsRunnable{ // 实现Runnable接口

public void run(){ // 覆写run()方法

for(int i=0;i<3;i++){

System.out.println(Thread.currentThread().getName()

+ "运行，i = " + i) ; // 取得当前线程的名字

}

}

};

public class Test{

public static void main(String args[]){

MyThread mt = new MyThread() ; //实例化Runnable子类对象

new Thread(mt,"线程").start() ; // 启动线程

mt.run() ; // 直接调用run()方法

}

};



注：主方法也是一个线程，在JAVA中所有的线程都是同时启动的，呢个线程先抢到CPU资源，那个线程就先使用。

问：JAVA中每次运行至少启动几个线程？

答：至少会启动两个，一个是main线程，一个是垃圾回收机制，System.gc();

线程中的一些具体方法：

start() --------->启动线程

stop() --------->关闭

isAlive()--------->测试线程是否已经启动而且仍然在运行。

join() --------->让一个线程强制运行

Thread.sleep(time) --------->实现休眠

Interrupt()---------> 可以通过中断其运行状体

yield() --------->将一个线程的操作暂时让给其他线程执行

可以使用setPriority（）方法可以设置一个线程的优先级：

Public staticfinal int MIN_PRIORITY 最低优先级 表示常量为1

Public staticfinal int NORM_PRIORITY 中等优先级 表示常量为5（main）

Public staticfinal int MAX_PRIORITY 最低优先级 表示常量为1

样板代码：

class MyThreadimplements Runnable{

private String name ;

private int time ;

public MyThread(String name,int time){

this.name = name ; // 设置线程名称

this.time = time ; // 设置休眠时间

}

public void run(){

try{

Thread.sleep(this.time) ; // 休眠指定的时间

}catch(InterruptedException e){

e.printStackTrace() ;

}

System.out.println(this.name +"线程，休眠"

+ this.time + "毫秒。") ;

}

};

public class Test{

public static void main(String args[]){

MyThread mt1 = new MyThread("线程A",10000) ; //定义线程对象，指定休眠时间

MyThread mt2 = new MyThread("线程B",20000) ; //定义线程对象，指定休眠时间

MyThread mt3 = new MyThread("线程C",30000) ; //定义线程对象，指定休眠时间

new Thread(mt1).start() ; // 启动线程

new Thread(mt2).start() ; // 启动线程

new Thread(mt3).start() ; // 启动线程

}

};



多线程安全问题的原因：

通过图解：发现一个线程在执行多条语句时，并运算同一个数据时，在执行过程中，其他线程参与进来，并操作了这个数据。导致到了错误数据的产生。

涉及到两个因素：

1、多个线程在操作共享数据。

2、有多条语句对共享数据进行运算。

原因：这多条语句，在某一个时刻被一个线程执行时，还没有执行完，就被其他线程执行了。

解决安全问题的原理：

只要将操作共享数据的语句在某一时段让一个线程执行完，在执行过程中，其他线程不能进来执行就可以解决这个问题。

如何进行多句操作共享数据代码的封装呢？

java中提供了一个解决方式：就是同步代码块。

格式：

synchronized(对象) { // 任意对象都可以。这个对象就是锁。

需要被同步的代码； }

wait和sleep区别： 分析这两个方法：从执行权和锁上来分析：

wait：可以指定时间也可以不指定时间。不指定时间，只能由对应的notify或者

notifyAll来唤醒。

sleep：必须指定时间，时间到自动从冻结状态转成运行状态(临时阻塞状态)。

wait：线程会释放执行权，而且线程会释放锁。

Sleep：线程会释放执行权，但不是不释放锁。

这里参考一个案例——————生产者与消费者

即：生产者生产一个产品，消费者取走一个产品

classInfo{ // 定义信息类

private String name = "张三"; // 定义name属性

private String content = "学习JAVA" ; // 定义content属性

private boolean flag = false ; // 设置标志位

public synchronized void set(Stringname,String content){

if(!flag){

try{

super.wait() ;

}catch(InterruptedException e){

e.printStackTrace() ;

}

}

this.setName(name) ; // 设置名称

try{

Thread.sleep(300) ;

}catch(InterruptedException e){

e.printStackTrace() ;

}

this.setContent(content) ; // 设置内容

flag = false ; // 改变标志位，表示可以取走

super.notify() ;

}

public synchronized void get(){

if(flag){

try{

super.wait() ;

}catch(InterruptedException e){

e.printStackTrace() ;

}

}

try{

Thread.sleep(300) ;

}catch(InterruptedException e){

e.printStackTrace() ;

}

System.out.println(this.getName() +

" --> " +this.getContent()) ;

flag = true ; // 改变标志位，表示可以生产

super.notify() ;

}

public void setName(String name){

this.name = name ;

}

public void setContent(String content){

this.content = content ;

}

public String getName(){

return this.name ;

}

public String getContent(){

return this.content ;

}

};

classProducer implements Runnable{ // 通过Runnable实现多线程

private Info info = null ; // 保存Info引用

public Producer(Info info){

this.info = info ;

}

public void run(){

boolean flag = false ; // 定义标记位

for(int i=0;i<50;i++){

if(flag){

this.info.set("张三","学习JAVA") ; // 设置名称

flag = false ;

}else{

this.info.set("csdn","www.csdn.com"); // 设置名称

flag = true ;

}

}

}

};

classConsumer implements Runnable{

private Info info = null ;

public Consumer(Info info){

this.info = info ;

}

public void run(){

for(int i=0;i<50;i++){

this.info.get() ;

}

}

};

publicclass ThreadCaseDemo03{

public static void main(String args[]){

Info info = new Info(); // 实例化Info对象

Producer pro = new Producer(info) ; // 生产者

Consumer con = new Consumer(info) ; // 消费者

new Thread(pro).start() ;

new Thread(con).start() ;

}

};



------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------