黑马程序员 多线程

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

1，进程与线程：

进程是一个正在执行中的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径或者叫一个控制单元。
线程就是进程中的一个独立的控制单元，线程在控制着进程的执行。
注意：jvm启动不止一个线程，除了主线程还有负责垃圾回收机制的线程。

2，创建线程的第一种方式：继承Thread类

(a)创建子类对象的同时就创建了线程，创建多少个子类对象就有多少条线程。

(b)步骤：
(1)定义类继承Thread。
(2)复写Thread类中的run方法。目的：将自定义代码存储在 run方法。让线程运行。
(3)调用线程的start方法。该方法两个作用：启动线程；调用 run方法。
(4)要是只调用run方法，这仅仅是调用对象的方法，而没有启动线程。
(c)多线程有一个特点：随机性。在互相抢夺cpu的执行权。
(d)线程都有自己默认的名称，Thread-编号 该编号从0开始。
static Thread currentThread():获取当前线程对象。
getName(): 获取线程名称。
设置线程名称：setName或者构造函数。
线程的状态图:

体现

public class Thread001 {
    public static void main(String[] args) {        
        Deme d = new Deme();
        d.start();  //开启线程  
        for (int i = 0; i < 60; i++) {//主线程
            System.out.println("main::"+i);
        }
    }
}
class Deme extends Thread{  //继承Thread类
    public void run(){      //自定义方法内容
        for (int i = 0; i < 60; i++) {
            System.out.println("Thread::"+i);
        }
    }
}

结果图：

3，创建线程的第二种方式：实现Runnable接口

步骤：
(a)定义类实现Runnable接口
(b)覆盖Runnable接口中的run方法。将线程要运行的代码存放在该run方法中。
(c)通过Thread类建立线程对象
(d)将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。因为自定义的run方法所属的对象是Runnable接口的子类对象，所以要让线程去指定对象的run方法。
Ticket类实现了Runnable接口
Ticket t=new Ticket();
Thread t1=new Thread(t)

4，实现方式和继承方式的区别

继承Thread:线程代码存放Thread子类run方法中。
实现Runnable：线程代码存放接口的子类的run方法。实现方式的好处是避免了单继承的局限性。

5，多线程的运行出现安全问题

(a)问题的原因
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程就参与进来执行，导致共享数据的错误。

体现:

public class Thread002 {
    public static void main(String[] args) {        
        Ticket tick = new Ticket();     
        Thread d1 = new Thread(tick);
        Thread d2 = new Thread(tick);
        Thread d3 = new Thread(tick);
        Thread d4 = new Thread(tick);
        d1.start();//开启线程
        d2.start();//开启线程
        d3.start();//开启线程
        d4.start();//开启线程
//      new Thread(tick).start();
//      new Thread(tick).start();
//      new Thread(tick).start();
//      new Thread(tick).start();       
    }
}
class Ticket implements Runnable{
    private int tick = 100;
    public void run() {
        while (true) {  //循环        
            if (tick>0) {
                try {
                    Thread.sleep(10);//稍微等待
                } catch (InterruptedException e) {
                    e.printStackTrace();//处理异常
                }
                System.out.println(Thread.currentThread().getName()+"....."+tick--);
            }       
        }
    }
}

结果图：

(b)解决办法

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

(c)多线程安全问题的解决办法是同步代码块:

synchronied（对象）
{需要被同步的代码}
对象如同锁。持有锁的线程可以在同步中执行，没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。例如，火车上的卫生间。

(d)同步的前提：

(1)必须要有两个或者两个以上的线程。
(2)必须是多个线程使用同一个锁,必须保证同步中只能有一个线程在运行。

(e)同步的优劣性：

(1)解决了多线程的安全问题。
(2)需要判断锁，降低效率。

(f)同步函数的锁是synchronized(this)；静态同步函数的锁是synchronized(类名.class)

(g)多线程的单例设计模式

懒汉式的特点是延迟加载实例，在多线程访问时，会出现安全问题，可以使用同步代码块或同步函数来解决，但比较低效，可以通过双重判断的形式来解决低效问题。同步所使用的锁是该类字节码文件对象。

体现：

//多线程单例设计模式—懒汉式  
class S  
{  
　　private static S s=null;  
　　private S (){};  
　　public static S getIns ()  
　　{  
                if(s==null)  
　　      {  
　　          synchronized(S.class)  
　　          {  
　　              if(s==null)  
　　                  s=new S();  
　　          }  
　　      }  
                return s;  
　　}  
}  

(h)死锁：同步中嵌套同步，使用不同的锁，万万不可。

体现：

class Test
{
        public static void main(String[] args)
        {
                Thread t1 = new Thread(new Run(true));
                Thread t2 = new Thread(new Run(false));
                t1.start();
                t2.start();
        }
}
class Run implements Runnable
{
        private boolean flag;
        public Run(boolean flag)
        {
                this.flag = flag;
        }
        public void run()
        {
                if(flag)
                {
                        synchronized(LockFactory.lockA)//同步锁A
                        {
                                System.out.println("if.....lockA");
                                synchronized(LockFactory.lockB)//同步锁B
                                {
                                        System.out.println("if.....lockB");
                                }
                        }
                }else
                {
                        synchronized(LockFactory.lockB)//同步锁B
                        {
                                System.out.println("else...lockB");
                                synchronized(LockFactory.lockA)//同步锁A
                                {
                                        System.out.println("else...lockA");
                                }
                        }
                }
        }
}
class LockFactory//用于提供锁的类
{
        static LockA lockA = new LockA();
        static LockB lockB = new LockB();
}
class LockA//锁A
{}
class LockB//锁B
{}

6，生产者与消费者的经典实例：

对于多个生产者和消费者，需要定义while判断标记。因为要让被唤醒的线程再一次判断标记。为什么定义notifyAll，因为需要唤醒对方线程。因为只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。
毕老师视频中使用whlie，wait，notifyAll解决问题，我觉得在那个例子上只需改动判断条件即可实现。

体现：

public class Thread003 {
    public static void main(String[] args) {
        R r=new R();
        P p = new P(r);
        C c = new C(r);
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(p);
        Thread t3 = new Thread(c);
        Thread t4 = new Thread(c);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}
class R{
    private String name;
    private int count = 1;
    private boolean flag = true;    
    public synchronized void set(String name){
        if (flag) {
            this.name = name + "---" + count++;
            System.out.println(Thread.currentThread().getName()+"...生产者..."+ this.name);
            flag = false;           
        }
    }   
    public synchronized void out(){
        if (!flag) {
            System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);
            flag = true;
        }
    }           
}
class P implements Runnable{
    private R r;
    P(R r){
        this.r=r;
    }   
    public void run() {     
        while (true) {
            r.set("++商品++");        
        }
    }
}
class C implements Runnable{
    private R r;
    C(R r){
        this.r=r;
    }
    public void run(){
        while (true) {
            r.out();            
        }
    }   
}

7，JDK1.5升级

JDK1.5中提供了多线程升级解决方案，将同步Synchronized替换成显示的Lock操作。将Object中的wait,notify,notifyAll，替换了Condition对象：await()，signal()，signalAll()。

8，停止线程

定义循环结束标记：因为线程运行代码一般都是循环，只要控制了循环即可。
使用interrupt（中断）方法:该方法是结束线程的交结状态，使线程回到运行状态中来。
注：stop方法已经过时不再使用。

9，守护线程

setDaemon(boolean on),该方法必须在启动线程前调用。守护线程依赖于主线程，当主线程运行结束，守护线程也跟着结束。
Thread t=new Thread(d);
t.setDaemon(true);
t.start();

10，join()方法

当A线程执行到了B线程的.join()方法时，A就会等待，等B线程都执行完，A才会执行。join可以用来临时加入线程执行。

11，优先级

t1.setPriority(Thread.MAX_PRIORITY);最高优先级

t2.setPriority(Thread.MIN_PRIORITY);最低优先级

t3.setPriority(Thread.NORM_PRIORITY);默认优先级

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