黑马程序员——多线程

 

　------- android培训、java培训、期待与您交流！ ----------

——————————————————————————————————————————————— 

21、多线程

|——概念：
线程就是进程中一个负责程序执行的控制单元（执行路径）。
进程中可以同时有多个执行路径
|——多核处理器可以真正意义上的多线程
|——JVM启动时，就启动了多个线程
有一个垃圾回收机制，显式 public static void gc()运行垃圾回收器。
protected void finalize()
当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。子类重写 finalize 方法，以配置系统资源或执行其他清除。
java中垃圾回收器由JVM直接调用。显式的调用System.gc();方法也不确定垃圾回收机制会被执行
class Demo {
protected void finalize() throws Throwable {
System.out.println("finalize called.");
}
}


class ThreadDemo{
public static void main(String []args){
new Demo();
new Demo();
System.gc();//显式的调用java的垃圾回收器
new Demo();
System.out.println("Main Thread end.");
}
}


//运行结果可能会出现以下多种情况：
————————————————————————————————————————————————
Main Thread end.
finalize called.//main线程执行完执行,这里主线程结束，垃圾回收器的线程还没有结束
————————————————————————————————————————————————
finalize called.
finalize called.
Main Thread end.//调用后直接执行
————————————————————————————————————————————————
Main Thread end.//程序结束也没有执行

|——线程的创建（示例）
注-->注-->线程可以由操作系统默认创建。JVM创建的线程都定义在了主函数中
|--创建新执行线程有两种方法。
|---一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。
|---另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。
然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动。

|---自定义线程
class MyThread extends Thread
class MyThread implements Runnable
|---开启线程的方法（对应上边的两个自定义线程）
new MyThread().start();
new Thread(new MyThread()).start();//这里只能这样开启，不能像Thread的子类那样
|--开启自定义线程要继承Thread类，并复写run方法。
注-->注--> 线程对象调用start()方法， 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
|--线程对象调用run方法，没有开启线程
|--线程创建的时候就已经确定了线程的编号。要获得线程开启的线程，使用Thread.currentThread.getName();
这里可以通过直接调用run方法看出，没有开启线程也有编号。
|——线程的状态：
被创建 运行 消亡 冻结（sleep()）
start run结束 wait(),唤醒用notify();

|--CPU的执行资格：可以被CPU的处理，在处理队列中排队
CPU的执行权：正在被CPU的处理

|——Runnable接口的出现就是将任务封装成一个对象。Thread 类也是Runnable接口的实现类
|——继承Thread类和实现Runnable接口的区别：
|--将线程的任务从线程的子类中分离出来，进行了单独的封装
按照面向对象的思想将任务封装成对象；
|--避免了java中类的单继承的局限性
|--所以一般情况下多用实现Runnable接口的方法，将任务封装成对象。符合了面向接口（面向对象）编程的思想。


|——示例1
class Demo extends Thread{
private String name;
Demo(String name){
this.name = name;
}
public void run(){
for(int x=0;x<10;x++)
System.out.println(name+"..."+x);
}
}


class ThreadDemo{
public static void main(String []args){
new Demo("zhangsan").start();
new Demo("lisi").start();
}
} 
//运行结果可能会出现以下多种情况：
————————————————————————————————————————————————
zhangsan...0 zhangsan...0
zhangsan...1 zhangsan...1
zhangsan...2 lisi...0
zhangsan...3 lisi...1
zhangsan...4 lisi...2
zhangsan...5 zhangsan...3
lisi...0 zhangsan...4
lisi...1 lisi...3
.. ..


|——示例2 //实现Runnable接口的类。注意开启线程的方法
// new Thread(new MyThread("xxxx")).start();
|--步骤：
定义类实现Runnable接口。
实现run方法，将线程的任务代码封装到run方法中。
通过Thread类创建线程对象，并将Runnable接口的实现类作为构造函数的参数进行传递


class MyThread implements Runnable{
private String name;
MyThread(String name){
this.name = name;
}
public void run(){
for(int x=0;x<10;x++)
System.out.println(name+"..."+Thread.currentThread().getName());
}
}

注-->注-->new MyThread().start();是错误的，编译就出现错误。这样不是开启线程
（向上转型，不能调用接口中没有的方法,也就是实现类的特有方法）
|——示例3 //Thread先找自己的run方法，如果自己需要开启的线程代码在
// 一个实现了Runnable接口的类中，
new Thread(new Runnable(){
实现Runnable接口的run方法；
})
{
重写Thread父类的run方法 //先找这里，如果找不到，就会找实现Runnable接口的run方法
}.start();

new Thread(new Runnable(){
public void run(){
System.out.println("runnable Thread called");
}
}){
public void run(){
System.out.println("My Thread called.");// 匿名线程类中有自己的run方法，
}//这个时候线程会先去找Thread（父类）run方法，如果找不到，会找Runnable子类的run方法
}.start();


|——示例4 卖票实例
|--以下两种都没有实现线程间的同步问题
1继承Thread类
——————————————————————————————————————————————————————————————
class MyThread extends Thread{//继承Thread类
private static int tickets = 100;//为了使多个线程共享着100张票，
// 将tickets设置为静态的（共享数据）
public void run(){
while(tickets>=0){
try{
Thread.sleep(1);
}catch(Exception e){}
System.out.println("tickets left "+(tickets--)+" ,Thread name : "+Thread.currentThread().getName());
}
}
}
class ThreadDemo{
public static void main(String []args)throws Exception{
MyThread mt1 = new MyThread();
MyThread mt2 = new MyThread();
mt1.start();
mt2.start();
}


2实现了Runnable接口 //这样的实现类称为线程任务类
——————————————————————————————————————————————————————————————


class MyThread implements Runnable{ //这里实现了Runnable接口
private int tickets = 100;//这里可以共享也可以不共享。
public void run(){
while(tickets>=0){ //假设有两个线程都进入到了这里，条件也判断过了，
// Thread-0还没有迹象执行，CPU切换到了Thread-1上。下次
// 切换过来的时候就不在进行判断
System.out.println("tickets left "+(tickets--)+
" ,Thread name : "+Thread.currentThread().getName());
}
}
}
//在主方法中这样开启线程
MyThread mt = new MyThread();
new Thread(mt).start();
new Thread(mt).start();

|——线程安全问题产生的原因：
多个线程在操作共享数据
操作共享数据线程代码有多条
|——解决线程安全问题：(同步代码块，用关键字 synchronized)
将需要同步的代码封装起来。只有当当前线程将这些代码执行完毕后，其他线程才能执行
|--同步的前提:
有多个 线程并使用同一个锁。
|--同步函数：在函数名前加 synchronized 同步函数的锁是 this
public synchronized void show(){
if(tickets>0)
// System.out.println("saled tickets:"+(100-tickets));
System.out.println("tickets left "+(tickets--)+
" ,Thread name : "+Thread.currentThread().getName());
}
public void run(){

while(true){
show();
}
}

注-->注-->|--一个普通方法和一个静态方法同步就需要用到字节码
静态方法就没有 this 需要用到类的字节码
|---获得字节码的两种方式：
对象.getClass();
类.class;

|--单例设计模式的线程安全问题：
|---饿汉式没有问题
|---懒汉式有线程安全问题

解决单例设计的第一种模式
同步函数：降低了效率
______________________________________________________
class Single{
private static final Single s = null;
public synchronized Single getInstance(){//
if(s == null)
s = new Single();
return s;
}
}

解决单例设计的第二种模式提高效率
同步代码块
______________________________________________________

class Single{
private static final Single s = null;
public synchronized Single getInstance(){//
if(s == null)
synchronized(Single.class){
if(s == null)
s = new Single();
}
return s;
}
}




|---死锁示例：
解析：
示例中有为了解决问题，又开启了两个线程，
class Demo implements Runnable{
boolean flag = true;
private int num = 100;
String s = "";

public synchronized void show(){
synchronized(s){ //Thread-0要进入这里的时候发现Thread-1拿着这个锁，等待
if(num>0){
System.out.println(Thread.currentThread().getName()+"....show.."+num--);
}
}
}
public void run(){
if(flag){ //Thread-0满足条件，拿到了s这个锁。这个时候可能Thread-1已经拿到了this这个锁。
while(num>0){ //加入两个线程各自拿到一个锁后，状态改变。两个线程还没有释放掉锁拿到的锁
synchronized(s){
show();
}
}
}
else{
while(num>0){
show(); //要运行到这里的时候，一看Thread-1拿着这个this锁。等待
}
}
}
}


public class ThreadDemo{
public static void main(String []args){
Demo d = new Demo();
new Thread(d).start();
try{Thread.sleep(1);}catch(InterruptedException e){}
d.flag = false;
new Thread(d).start();
}
}



死锁清晰实例
————————————————————————————————————————————————————————————————————

class MyLock{
public static final MyLock locka = new MyLock();
public static final MyLock lockb = new MyLock();
}


class Demo implements Runnable{
boolean flag ;
Demo(boolean flag){
this.flag = flag;
}
public void run(){
if(flag){
synchronized(MyLock.locka){
System.out.println(Thread.currentThread().getName()+"..if ..locka..");
synchronized(MyLock.lockb){
System.out.println(Thread.currentThread().getName()+"..if ..lockb..");
// try{Thread.sleep(10);}catch(InterruptedException e){}
}
}
}
else{
synchronized(MyLock.lockb){
System.out.println(Thread.currentThread().getName()+"..else ..lockb..");
synchronized(MyLock.locka){
System.out.println(Thread.currentThread().getName()+"..else ..locka..");
}
}
}
}
}


public class ThreadDemo{
public static void main(String []args){
Demo d1 = new Demo(true);
Demo d2 = new Demo(false);
new Thread(d1).start();
new Thread(d2).start();

}
}

|——线程间通信 (等待唤醒机制)
|--wait(); 让线程处于冻结状态，被wait的线程会被存储到线程池中
notify(); 唤醒线程池中的一个线程。（任意）
notifyAll();唤醒线程池中的所有线程
|--这些方法都 必须定义在同步中，
因为这些方法是用于操作线程状态的方法，
必须要明确到底操作的是哪个锁。
class Resource{
String name;
String sex;


boolean flag = true;
public synchronized void put(String name,String sex){
if(!flag){
try {
wait();//当标志位为false，线程wait这里其实是r.wait();
} catch (InterruptedException e1){}
}
this.name = name;
this .sex = sex;

flag = false; //执行完后，将标志位状态改变。
notify(); //并且唤醒一个线程这里其实是r.notify();
}

public synchronized void get(){
if(flag){
try {
wait();    //当标志位为true，线程wait。这里其实是r.wait();
} catch (InterruptedException e1){}
}
System.out.println(name+"....."+sex);

flag = true;//执行完后，将标志位状态改变。
notify();//并且唤醒一个线程这里其实是r.notify();
} 
}


class Input implements Runnable{
Resource r ;
private int x=0;
Input(Resource r){
this.r = r;
}
public  void run(){   //这里有一个线程任务
while(true){
if(x == 0){
r.put("zhangsan","nan");//这里可以将同步代码封装
}else{
r.put("lisi","nv");
}
x = (x+1)%2;
}
}
}


class Output implements Runnable{
Resource r ;
Output(Resource r){
this.r = r;
}

public void run(){ //这里有一个线程任务
while(true){
r.get(); //这里可以将同步代码封装
}
}
}


经典 多生产者多消费者问题
——————————————————————————————————————————————————————————————————
语言描述：
两个知识点：
用while不用if判断标记   ，解决了可能出现的一个重复生产，或者一个重复消费的情况
用notifyAll()不用notify(); //避免生产线程唤醒生产线程（这样在while下一判断，又跑线程池里了），
// 避免消费线程唤醒消费线程。这是产生死锁的情况
这里有四个线程:
Thread-0和Thread-1作为生产者：
Thread-2和Thread-3作为消费者：
flag一开始是false，当Thread-0来到线程任务后，判断flag，flag为false。Thread-0生产了一只烤鸭。
此时notify()或是notifyAll()是没有唤醒任何线程池中的线程。
将flag设置为true。如果用notify()，任意唤醒一个线程。可能是Thread-1；
假设这个时候：Thread-1也来到线程生产任务。进行等待，Thread-1进入线程池。
这个时候flag依然还是true，Thread-0进入生产线程。判断后也进入等待，Thread-0也会进入线程池。
此时生产线程都没有了执行权
同理，消费者也是一样的。

if和while
if(flag)
try {wait();} catch (InterruptedException e){}
Thread-0 到这里以判断，flag为false。直接往下运行。生产烤鸭1
flag = true;

Thread-2 判断一次，flag为true，向下运行，消费烤鸭1
flag = false;
Thread-3判断一次，flag为false，Thread-3被冻结
Thread-1到这里判断，flag为false。
flag = true；
Thread-2 判断一次，flag为true。唤醒了Thread-3，这个时候就不在进行判断。直接消费一次。
这样就出现了同一只烤鸭消费了两次

/* // Thread-1到这里判断，flag为true。Thread-1冻结。
// 这个时候线程池中只有Thread-1 ，唤醒了Thread-1。
// Thread-1 直接往下运行（if不在进行判断），生产烤鸭2
flag = true;
假设这个时候又来了Thread-0 ,判断后，wait()Thead-0进入线程池。
Thread-1来了后，flag为true，向下运行，消费烤鸭2 */


class Resource{
private String name ;
private int count =1;
private boolean flag = false;

public synchronized void put(String name){
while(flag) //这里用while不用if，目的是在线程唤醒后再判断一次
try {wait();} catch (InterruptedException e){} //Thread-
this.name = name+count;
count++;
System.out.println(Thread.currentThread().getName()+"...Producer..........s"+this.name);
flag = true;
notifyAll();
}

public synchronized void get(){
while(!flag)
try {wait();} catch (InterruptedException e){}
System.out.println(Thread.currentThread().getName()+"...xiaofeile...."+name);
flag = false;
notifyAll();
}
}
// 生产者线程任务类
class Producer implements Runnable{
Resource r ;
Producer(Resource r){
this.r = r;
}

public void run(){
while(true)
r.put("kaoya");
}
}
 
//消费者线程任务类
class Constumer implements Runnable{
Resource r ;
Constumer(Resource r){
this.r = r;
}

public void run(){
while(true)
r.get();
}
}
 
public class ProducerDemo{
public static void main(String []args){
Resource r = new Resource();
Producer p1 = new Producer(r);
Producer p2 = new Producer(r);
Constumer c1 = new Constumer(r);
Constumer c2 = new Constumer(r);

new Thread(p1).start();
new Thread(p2).start();
new Thread(c1).start();
new Thread(c2).start();
}
} 
 
|——java 1.5的新特性

Lock 实现提供了比使用 synchronized 
方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的 Condition 对象。 
 
Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 
实现组合使用，为每个对象提供多个等待 set（wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 
Object 监视器方法的使用

对比以上示例：
使用了一个锁，两个监视器。目的是，实现线程间的同步（互斥）。唤醒机制，只唤醒需要监视器中的线程对象
public void put(String name){
lock.lock(); //直接在这里加了锁，相当于家里synshronized将函数同步
try{
while(flag) //这里使用的是监视器con1的await()方法
try {con1.await();} catch (InterruptedException e){ e.printStackTrace();}
this.name = name+count;
count++;
System.out.println(Thread.currentThread().getName()+"...Producer..........s"+this.name);
flag = true;
// notifyAll();
con2.signal(); //这里使用的是监视器的signal，唤醒消费者线程（任意一个）。
}
finally{
lock.unlock(); //锁用完了就要释放掉
}

}

public void get(){
lock.lock();
try{
while(!flag) //这里使用的是监视器con2的await()方法
try {con2.await();} catch (InterruptedException e){e.printStackTrace();}
System.out.println(Thread.currentThread().getName()+"...xiaofeile...."+name);
flag = false;
// notifyAll();
con1.signalAll();//这里使用的是监视器的signal，唤醒生产者线程（任意一个）。
}
finally{
lock.unlock();
}
}
}
 
上边示例中出现了Lock接口：替代了同步代码块或者同步函数。将同步的隐式操作变成显示锁，
并且更加灵活。(可以使用多组监视器)

|--守护线程（幽灵线程）
后台线程和前台线程同样都开启。前台线程必须手动结束，后台线程在前台线程结束的情况下，后台线程也会自动消失

 

　------- android培训、java培训、期待与您交流！ ----------

———————————————————————————————————————————————