java多线程

多线程
1.1 多线程的概念


进程：正在进行中的程序。
线程：进程中一个负责执行的控制单元。


解析：
1.一个进程中可以有多个线程，称之为多线程。
2.一个进程中至少有一个线程，称为主线程

3.开启多个线程是为了同时运行多部分代码，每个线程都有自己运行的内容，这个内容称为线程需要执行的任务。

多线程的好处：解决了多部分代码同时运行的问题。
多线程的弊端：线程太多会导致效率的降低。
程序执行特点：其实， 多个应用程序同时执行都是CPU在做着快速的切换完成的。 这个切换是随机的。 CPU的切换是需要花
费时间的， 从而导致了效率的降低。
1.2 线程创建于执行


创建的方式之一：继承Thread类
1.定义一个继承Thread类。
2.覆盖Thread类中的run方法。
3.直接创建Thread的子类对象创建线程。
4.调用start方法开启线程并调用线程的run方法。


thread中的几种常见方法：
1.Thread.currentThread():获取当前现成的对象。
2.t.getName()；获取t线程对象的名称。格式：Thread-编号（从0开始）


示例：
[java] view plaincopy
class Demo extends Thread{  
    String name ;  
    Demo(String name){  
        this.name = name;  
    }  
    public void run(){  
        for(int x=0;x<10;x++){  
            System.out.println(name+"... x="+x+"... ThreadName="+Thread.currentThread().getName());  
        }         
    }   
}  
  
class ThreadDemo{  
    public static void main(String[] args){  
        Demo d1 = new Demo("旺财");  
        Demo d2 = new Demo("小黄");  
  
        d1.start();  
        d2.start();  
          
        for(int x=0;x<10;x++){  
            System.out.println("x="+x+"... ThreadName="+Thread.currentThread().getName());  
        }     
    }  
}  


运行结果：
发现三个输出语句无序的打印出来。


创建的方式之二：实现Runnable接口
1.定义一个类实现Runnable接口。
2.覆盖接口中的run方法，将线程将要执行的代码放入其中。
3.通过Thread类创建对象，并把实现了Runnable的子类对象作为参数传给Thread类的构造函数。
4.调用Thread中的start方法，开启线程。


实现Runnable的好处：
1.将线程的任务从线程子类中分离出来，进行了单独的封装，安装面向对象的思想将任务封装成了对象。
2.避免了java单继承的局限性。
3.实现Runnable方法更为常见。
示例：
[java] view plaincopy
class Demo implements Runnable{  
    public void run(){  
        show();  
    }  
    public void show(){  
        for(int x=0;x<10;x++){  
            System.out.println("x="+x+"... ThreadName="+Thread.currentThread().getName());  
        }  
    }  
}  
  
class ThreadDemo{  
    public static void main(String[] args){  
        Demo d1 = new Demo();  
          
        Thread t1 = new Thread(d1);  
        Thread t2 = new Thread(d1);  
  
        t1.start();//可简写为new Thread(d1).start();  
        t2.start();  
    }  
}  


运行结果：两个线程无序的把0-9依次打印出来。
1.3 线程安全性问题。


举例说明问题：
需求：模拟4个窗口卖票的问题。
代码：
[java] view plaincopy
class Ticket implements Runnable{  
    private int num = 100;  
    public void run(){  
        while(true){          
            if(num>0){  
                System.out.println(Thread.currentThread().getName()+"...sale...."+num--）；  
            }         
        }     
    }  
}  
  
class TicketDemo{  
    public static void main(String[] args){  
        Ticket t = new Ticket();  
          
        new Thread(t).start();  
        new Thread(t).start();  
        new Thread(t).start();  
        new Thread(t).start();  
    }  
}  


运行结果：
发现运行出现两个99和出现0，-1的情况。


分析：
因为cpu执行多线程时，是在多线程之间快速切换的，当线程-0执行到num=1但为对其自减就停止了，此时线程-1进来了num没有变化，输出后num自减num=0，回到线程-0，输出的就是num=0了。


线程安全问题的产生：
1.多个线程同时操作共享数据时。
2.操作的共享数据的代码有多条。
1.4 线程安全问题的解决方案


思路：将多个线程执行的代码封装在一个空间内，一次只让一个线程执行其中的代码。
方法：使用synchronized（同步）
格式：
synchronized（对象）{
需要被同步的代码，即多线程执行的代码；
}


同步的好处：解决了多线程的安全性问题。
同步的弊端：当线程相当多时，同一时间只有一个线程在执行，降低了运行的效率。
同步的前提：必须有多个线程并使用同一个锁。


卖票修改后代码：
[java] view plaincopy
class Ticket implements Runnable{  
    private int num = 100;  
    Object obj  = new Object;//同步需要锁，锁为一个对象或者一个class文件，这里用Object对象。  
  
    public void run(){  
        while(true){  
            synchronized(obj){  
                if(num>0){  
                System.out.println(Thread.currentThread().getName()+"...sale...."+num--）；  
                }  
            }                 
        }     
    }  
}  


利用同步带代码块解决安全性问题：


需求：储户，两个，每个都到银行存钱，每次存入100，共存三次。


[java] view plaincopy
class Bank{  
    private int sum;  
    public void add(int num){  
        synchronizd(this){  
            sum = sum + num;  
            System.out.println("sum = "+sum);  
        }         
    }  
}  
  
class Cus implements Runnable{  
    private Bank b = new Bank();  
    public void run(){  
        for(int x = 1;x<=3;x++){  
            d.add(100);  
        }  
    }  
}  
  
class BankDemo{  
    public static void main(String[] args){  
        Cus c = new Cus();  
  
        new Thread(c).strat();  
        new Thread(c).strat();  
    }  
}  


运行结果：
sum = 100
sum = 200
sum = 300
sum = 400
sum = 500
sum = 600




synchronized可作为修饰符放在函数中，称为同步函数。
格式：
public synchronized void add（int num）{
同步代码；
}


同步代码和同步函数的区别：同步代码的锁为自定义的，而同步函数的锁为固定的this。建议使用同步代码块。
静态的同步函数使用的锁是干函数所属字节码文件对象，可以用 对象.getClass() 方法获取，也可以用 类.class() 表示，还可通过 Class.forName(类名) 获取。
1.5 死锁示例
一般出现在同步嵌套中，即同步中有同步,并且锁用的不同。


示例
[java] view plaincopy
class DieLock implement Runnable{  
  
  
    Object obja = new Object();  
    Object objb = new Object();  
    boolean flag = true;  
  
    public void run(){  
        if(flag){  
            synchroinzed(obja){  
                System.out.println("hellow obja");  
                synchroinzed(objb){  
                    System.out.println("hellow objb");  
                }  
            }  
        }  
        else{  
            synchroinzed(objb){  
                System.out.println("hellow objb");  
                synchroinzed(obja){  
                    System.out.println("hellow obja");  
                }  
        }  
    }  
      
}  
  
class Demo{  
    public static void main(String[] args){  
        DieLock d = new DieLock();  
  
        new Thread(d).strat();  
        new Thread(d).strat();  
    }  
}  


死锁运行后出现，光标停在一个位置不动。
1.6 线程间的通讯
当多个线程对同一资源进行操作，而操作的方法却不同时，就需要多线程通讯。
等待/唤醒机制涉及的方法：
1.wait()：让线程处于冻结状态，被wait()的线程会被存储到线程池中。
2.notify()：唤醒线程池中的线程（按被冻结的顺序）。
3.notifyAll()：唤醒线程池中所有的线程。
4.这些方法都被定义在object中。
注意点：
1.这些方法必须定义在同步中，因为这些方法是用于操作线程状态的方法。
2.必须要明确到底操作的是哪个锁上的线程。
3.wait和sleep的区别
  1）wait可以指定时间也可以不指定时间，而sleep必须执行时间。
  2）在同步中，对cup执行权和锁的处理
     wait：释放执行权，释放锁。
    sleep：释放执行权，不释放锁。
4.两种方法都涉及到 InterruptedException 需要处理
输入/输出 姓名/性别 例：
[java] view plaincopy
class Resource{  
    private String name;  
    private String sex;  
    boolean flag = false;  
      
    public synchronized viod set(String name ,String age){  
        if(flag){  
            try{  
                this.wait();  
            }  
            catch(InterruptedException e){  
                e.printStackTrace();  
            }  
        }  
        this.name = name ;  
        this.sex = sex;  
        flag = true;  
        this.notify();        
    }  
  
    public synchronized void out(){  
        if(!flag){  
            try{  
                this.wait();  
            }  
            catch(InterruptedException e){  
                e.printStackTrace();  
            }  
        }  
        System.out.println("name = "+name+"sex = "+sex);  
        flag = false;  
        this.notify();  
    }   
}  
  
class Input implements Runnable{  
    Resource r ;  
    Input(Resource r){  
        this.r = r;  
    }  
      
    public void run(){  
        int x = 0  
        while(true){  
            if(x==0)  
                r.set("张华","男");  
            if(x==1)  
                r.set("丽丽","女");  
            x=(x+1)%2;  
        }  
    }  
}  
  
class Output implement Runnable{  
    Resource r;  
    Out(Resource r){  
        this.r = r;  
    }  
      
    public void run(){  
        while(true){  
            r.out();  
        }  
    }  
}  
  
class ResourceDemo{  
    public static void main(String[] args){  
        Resource r = new Resource;  
          
        new Thread(new Input(r)).strat();  
        new Thread(new OutPut(r)).strat();  
    }  
}  


运行结果：
name = 张华sex =男
name = 丽丽sex =女
无序交替出现。
注意：当对资源的同一方法有多个线程在操作，判断用while，而且唤醒用notifyAll()。
1.7 JDK1.5特性（Lock）
Lock接口：出现代替同步代码块或者同步函数，将同步的隐式操作变成了显示操作。同时更为灵活，可以一个锁上加上多个监视器。
格式：
1.获得锁对象
  Lock lock = new ReentrantLock();
  lock.lock();
2.获得监视器（可获得多个监视器）
  Condition con_p = lock.newCondition();
  Condition con_c = lock.newCondition();
3.等待(有抛出异常)
  con_p.await();
4.唤醒
  con_p.signal();
5.释放锁（在finally语句中为一定要执行语句）
  lock.unlock();


示例：
多个生产者、消费者


[java] view plaincopy
class Resource{  
    String name ;  
    int count = 1;  
    boolean flag = false;  
      
    Lock lock = new ReentrantLock();  
  
    Condition con_p = lock.newCondition();  
    Condition con_c = lock.newCondition();  
  
  
    public void set(String name){  
        lock.lock();  
  
        try{  
            while(flag){  
                try{  
                    con_p.await();  
                }catch(InterruptedException e){  
                    e.printStackTrace();  
                }  
            }  
            this.name = name + count;  
            count++  
            System.out.println(Thread.currentThread().getName()+"..生产.."+this.name);  
            flag = true;  
            con_c.signal();  
        }  
        finally{  
            lock.unlock();  
        }  
    }  
  
    public void out(){  
        lock.lock();  
  
        try{  
            while(!flag){  
                try{  
                    con_c.await();  
                }catch(InterruptedException e){  
                    e.printStackTrace();  
                }  
            }  
            System.out.println(Thread.currentThread().getName()+"..消费.."+this.name);  
            flag = false;  
            con_p.signal();  
        }  
        finally{  
            lock.unlock();  
        }  
    }  
}  
  
class Producer implements Runnable{  
    Resource r;  
    Producer(Resource r){  
        this.r = r;  
    }  
      
    public void run(){  
        while(true){  
            r.set("烤鸭")；  
        }  
    }  
}  
class Consumer implements Runnable{  
    Resource r;  
    Producer(Resource r){  
        this.r = r;  
    }  
      
    public void run(){  
        while(true){  
            r.out()；  
        }  
    }  
}  
class ResourceDemo{  
    public static void main(String[] args){  
        Resource r = new Resource;  
          
        new Thread(new Producer(r)).strat();  
        new Thread(new Producer(r)).strat();  
        new Thread(new Consumer(r)).strat();  
        new Thread(new Consumer(r)).strat();  
    }  
}  


运行结果：
生产消费同一产品依次输出。
1.8 线程中其他方法：
1.停止线程：stop方法已经过时，怎么控制线程的结束，线程任务中都会有循环结构，只要控制循环就能结束任务。
2.t.interrupt()：强制将处于冻结状态的t线程唤醒，但出现了InterruptedException异常需要处理。
3.t.setDeamon(true)：守护线程，随着主线程的结束而结束。
4.t.join()：抢夺执行权，等t线程运行完后在执行其他线程内容。
5.t.toString：返回线程的字符串表示形式：线程名称 优先级 线程组
6.t.setPriority（5）：设置t线程的优先级（0-9），默认为5
7.t.yeild()：停止t线程，执行其他线程。