黑马程序员——java学习6（127-151）——多线程

1、多线程

进程:是一个正在执行中的程序。

　　每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫控制单元。

线程：就是进程中的一个独立的控制单元

　　线程在控制着进程的执行

一个进程中至少有一个线程。

Java VM 启动的时候回有一个进程java.exe

该进程中至少一个线程负责java程序的执行

而且这个线程运行的代码存在于main方法中

该线程称之为主线程。

扩展：其实更细节说明jvm，启动的还有垃圾回收机制的线程

 创建线程的方式

1.1继承Thread

(1)定义类，继承Thread

(2)覆写Thread类中的run方法

　　目的：将自定义的代码存储在run方法中，让线程运行。

(3)调用线程的start方法，

　　　作用：启动线程，调用run方法.

多线程的随机性：每次运行结果不同，单核CPU在某一个时刻只能执行一个程序，cpu在快速切换，以达到看上去同时运行的效果。

1.1.1为何覆盖run方法？

Thread用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。

即run用于存储线程要运行的代码。

class Demo extends Thread{
    public void run(){
        for(int x=0;x<60;x++)
        {
            System.out.println("demo run---"+x);
        }
    };
}
public class ThreadDemo {
    public static void main(String[] args) {
        Demo d=new Demo();
        //d.start();//开启线程并执行该线程的run方法，demorun与helloworld相互执行
        d.run();//仅仅是对象调用方法，而线程创建了，并没有运行,demorun全部执行完才执行helloworld
        for(int x=0;x<60;x++)
        {
            System.out.println("Helloworld---"+x);
        }
}
}

1.1.2、线程方法

static Thread currentThread();获取当前线程对象，静态的，调用时为Thread.currentThread();

getName();获取线程名称

设置线程名称:setName();或者构造函数

1.2、创建线程的第二种方法（常用）

（1）定义类实现Runnable接口

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

　　将线程要运行的代码存放在该run方法中

（3）通过Thread类建立线程对象

（4）将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数

　　为何将Runnable接口的子类对象传递

　　因为自定义的run方法所述的对象是Runnable接口的子类对象

　　所以要让线程去执行指定对象的run方法，就必须明确该run所属对象

（5）调用Thread类的start方法开启线程并调用Runnable接口子类的run方法

好处：避免单继承的局限性

区别：

继承Runnable：线程代码存放在Thread子类的run方法中,无父类时用

实现Runnable：线程代码存在接口的子类的run方法中，避免局限

/*
 * 需求：
 * 银行有一个金库
 * 有两个储户分别存300元，每次存100，分3次
 * 
 * 目的：该程序是否有安全问题，如果有，如何解决？
 * 
 * 如何找问题
 * 1、明确哪些代码是多线程运行代码
 * 2、明确共享数据
 * 3、明确多线程运行代码中哪些语句是操作共享数据的
 * */

package learn;
class Bank
{
    private int sum;
    public void add(int n)
    {
        sum=sum+n;
        try{Thread.sleep(10);}catch(Exception e){}
        System.out.println("sum"+sum);
    }
}
class Cus implements Runnable
{
    private Bank b=new Bank();
    public void run()
    {
        for(int x=0;x<3;x++)
        {
            b.add(100);
        }
    }
}
public class BankDemo {
    public static void main(String[] args) {
        Cus c=new Cus();
        Thread t1=new Thread(c);
        Thread t2=new Thread(c);
        t1.start();
        t2.start();
    }
}

1.3、安全问题

当多条语句操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，

另一个线程参与执行，导致共享数据的错误

解决办法：

　　对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中其他线程不可参与执行

同步代码块。

synchronized(对象)

{

　　需要被同步的代码　　

}

例：火车上的厕所

同步的前提：

（1）必须有两个或以上的线程

（2）必须多个线程使用同一个锁

PS：必须保证同步中只有一个线程在执行

好处：解决了多线程的安全问题

弊端：判断锁，消耗资源

同步的方式：

（1）同步代码块，使用的锁是obj

（2）同步函数（作修饰符加入），使用的锁是this

（3）静态方法用过的锁是class，即该方法所在类的字节码文件对象，函数列表中写作（类名.class）

1.4、单例

package learn;
/*
 * class Single
 * {
 *     private static final Single s=new Single();
 *  private Single(){};
 *  public static Single getInstance()
 *  {
 *      return s;
 *  }
 * }
 * */延迟加载的单例模式示例
class Single
{
    private static Single s=null;
    private Single(){}
    public static Single getInstance(){
        if(s==null)
            synchronized(Single.class){
                if(s==null)
                    s=new Single();
            }
        return s;
    }
}
public class SingleDemo {

}

1.5、死锁

同步中嵌套同步

package learn;
class Test implements Runnable
{
    private boolean flag;
    Test(boolean flag)
    {
        this.flag=flag;
    }
    public void run(){
        if(flag)
        {
            synchronized(MyLock.locka)
            {
                System.out.println("if locka ");
                synchronized(MyLock.lockb)
                {
                    System.out.println("if lockb");
                }
            }
        }
        else
        {
            synchronized(MyLock.lockb)
            {
                System.out.println("else lockb");
                synchronized(MyLock.locka)
                {
                    System.out.println("else locka");
                }
            }
        }
    }
}

class MyLock{
    static Object locka=new Object();
    static Object lockb=new Object();
}
public class DeadLockTicket {
    public static void main(String[] args) {
        Thread t1=new Thread(new Test(true));
        Thread t2=new Thread(new Test(false));
        t1.start();
        t2.start();
    }
}

1.6、线程间通信

1.6.1等待唤醒机制

wait都存放在线程池，notify通常唤醒第一个被等待的，notifyall唤醒全部，三者都必须用在同步中（因须有锁），也需加前缀obj.wait

只有同一个锁上的被等待线程，可以被同一个锁上的notify唤醒

而锁是任意对象，所以可以被任意对象调用的方法定义在object类中

package learn;
class Res{
    private String name;
    private String sex;
    private boolean flag=false;
    public synchronized void set(String name,String sex)
    {
        if(flag)
            try{this.wait();}catch(Exception e){}
        this.name=name;
        this.sex=sex;
        flag=true;
        this.notify();
    }
    public synchronized void out()
    {
        if(!flag)
            try{this.wait();}catch(Exception e){}
        System.out.println(name+"..."+sex);
        flag=false;
        this.notify();
    }
}

class Input implements Runnable{
    private Res r;
    Input(Res r)
    {
        this.r=r;
    }
    public void run()
    {
        int x=0;
        while(true)
        {
            if(x==0)        
                r.set("mike", "nan");            
            else            
                r.set("lili", "nv");
            x=(x+1)%2; 
        }
    }

}

class Output implements Runnable{
    private Res r;
    Output(Res r)
    {
        this.r=r;
    } 
    public void run()
    {
        int x=0;
        while(true)
        {
            r.out();
        }
    }
}
public class InputOutputDemo {
    public static void main(String[] args) {
        Res r=new Res();
        //匿名对象
        new Thread(new Input(r)).start();
        new Thread(new Output(r)).start();
        
//        Input in=new Input(r);
//        Output out =new Output(r);
//        Thread t1=new Thread(in);
//        Thread t2=new Thread(out);
//        t1.start();
//        t2.start();
    }
}

1.6.2、生产者消费者例子

多个生产者，多个消费者，while循环判断标记，notifyAll

package pack;
class Resource{
    private String name;
    private int count=1;
    private boolean flag=false;
    
    public  synchronized void set(String name)
    {
        while(flag)
            try{wait();}catch(Exception e){}
        this.name=name+"..."+count++;
        System.out.println(Thread.currentThread().getName()+"生产者"+this.name);
        flag=true;
        this.notifyAll();
    }
    public synchronized void out(){
        while(!flag)
            try{wait();}catch(Exception e){}
        System.out.println(Thread.currentThread().getName()+"消费者............"+this.name);
        flag=false;
        this.notifyAll();
    }
}

class Producer implements Runnable{
    private Resource res;
    Producer(Resource res){
        this.res=res;
    }
    public void run(){
        while(true)
        {
            res.set("+商品+");
        }
    }
}

class Consumer implements Runnable{
    private Resource res;
    Consumer(Resource res){
        this.res=res;
    }
    public void run(){
        while(true)
        {
            res.out();
        }
    }
}
public class ProduceConsumerDemo {
    public static void main(String[] args) {
        Resource r=new Resource();
        Producer pro=new Producer(r);
        Consumer con=new Consumer(r);
        
        Thread t1=new Thread(pro);
        Thread t2=new Thread(pro);
        Thread t3=new Thread(con);
        Thread t4=new Thread(con);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

1.6.3、多线程升级锁Lock

JDK1.5中提供了多线程升级解决方案

将同步syn替换成现实Lock操作

将Object中的wait,notify,notifyAll，替换了Condition对象

该对象可以Lock锁，进行获取

实现了本方只唤醒对方操作

package learn;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Resource{
    private String name;
    private int count=1;
    private boolean flag=false;
    private Lock lock=new ReentrantLock();
    private Condition condition_pro=lock.newCondition();
    private Condition condition_con=lock.newCondition();
    public  void set(String name)throws InterruptedException
    {
        lock.lock();
        try{    
            while(flag)
            condition_pro.await();
            this.name=name+"..."+count++;
            System.out.println(Thread.currentThread().getName()+"生产者"+this.name);
            flag=true;    
            condition_con.signal();
        }
        finally{
            lock.unlock();
        }
        
    }
    public void out()throws InterruptedException{
        lock.lock();
        try{
        while(!flag)
            condition_con.await();
        System.out.println(Thread.currentThread().getName()+"消费者............"+this.name);
        flag=false;
        condition_pro.signal();
        }
        
        finally
        {
            lock.unlock();
        }
    }
}

class Producer implements Runnable{
    private Resource res;
    Producer(Resource res){
        this.res=res;
    }
    public void run(){
        try{
        while(true)
        {
            res.set("+商品+");
        }
        }
        catch(Exception e)
        {}
    }
}

class Consumer implements Runnable{
    private Resource res;
    Consumer(Resource res){
        this.res=res;
    }
    public void run(){
        while(true)
        {
            try{
            res.out();
            }
            catch(Exception e)
            {}
        }
    }
}
public class ProducerConsumerDemo2 {
    public static void main(String[] args) {
        Resource r=new Resource();
        Producer pro=new Producer(r);
        Consumer con=new Consumer(r);
        
        Thread t1=new Thread(pro);
        Thread t2=new Thread(pro);
        Thread t3=new Thread(con);
        Thread t4=new Thread(con);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

1.7、如何停止线程？

stop方法已过时，只能让run方法结束，即控制run中的循环结束

特殊情况：

当线程处于冻结状态

就不会读取到标记，那么线程就不会结束

当没有指定的方式让冻结的线程回复到运行状态时，这时需要对冻结进行清除

强制让线程回复到运行状态中来，这样就可以操作标记让线程结束

interrput();方法

1.8、守护线程

1.9、join

当A线程执行到B线程的join方法时，A就会等到B执行完再执行

package pack;
class Demo implements Runnable
{
    public void run(){
        for(int x=0;x<70;x++)
            System.out.println(Thread.currentThread().getName()+"..."+x);
    }
}
public class JoinDemo {
 public static void main(String[] args) throws InterruptedException {
    Demo d=new Demo();
    Thread t1=new Thread(d);
    Thread t2=new Thread(d);
    t1.start();
    //t1抢夺CPU执行权
    t1.join();
    t2.start();
    
    for(int x=0;x<80;x++)
    {
        System.out.println("main..."+x);
    }
    System.out.println("over");
}
}

1.9.1、线程优先级

所有线程默认优先级5，一共1-10级

1.9.2、yield();

尽量轮流执行

1.9.3、开发举例

package pack;

public class ThreadTest {
    public static void main(String[] args) {
        //匿名内部类更方便
        new Thread()
        {
            public void run()
            {
                for(int x=0;x<100;x++)
                {
                    System.out.println(Thread.currentThread().getName()+"..."+x);
                }
            }
        }.start();
        
        for(int x=0;x<100;x++)
        {
            System.out.println(Thread.currentThread().getName()+"..."+x);
        }
            
        
        Runnable r=new Runnable(){
            public void run(){
                for(int x=0;x<100;x++)
                {
                    System.out.println(Thread.currentThread().getName()+"..."+x);
                }
                
            }    
        };
        new Thread(r).start();
    }
}

//麻烦
//class Test1 extends Thread
//{
//    public void run()
//    {
//        for(int x=0;x<100;x++)
//            System.out.println(Thread.currentThread().getName());
//    }
//}