七.多线程技术

多线程技术

多线程基本概念_程序_进程_线程

   ·程序、进程、线程

　　程序：（program）是一个指令的集合

　　进程：Process,（正在执行中的程序）是一个静态的概念。进程是程序的异常静态执行过程，占用特定的地址空间，每个进程都是独立的，有3部分组成cup,data,code

　　缺点：内存的浪费，CPU的负担

　　线程：是进程中一个“单一的连续控制流程”。CPU调度的是线程

通过继承Thread类实现多线程

   ·实现多线程的步骤

　　1.继承Thread类

　　2.重写run()方法

　　3.通过start()方法启动线程

package com.zqf.threadproject;

public class Test {
    public static void main(String[] args) {
        MyThread my = new MyThread();
        my.start();        //启动线程
        System.out.println("-------main");
    }
}

package com.zqf.threadproject;

public class MyThread {

    public void start() {
        // TODO Auto-generated method stub
        //线程体
        System.out.println("MyThread-----");
    }
}

通过实现Runnable接口实现多线程

   ·步骤

1. 编写类实现Runnable接口
2. 实现run()方法
3. 通过Thread类的start()方法启动线程

   package com.zqf.runnableproject;
   
   public class test1 {
       public static void main(String[] args) {
           //创建线程类的对象
           MyRunnable my=new MyRunnable();
           //start()方法是Thread类中的方法
           Thread t = new Thread(my);
           t.start();    //启动线程
           //主线程中的循环
           for(int i=0;i<10;i++){
               System.out.println("-------mian()");
           }
       }
   }

   package com.zqf.runnableproject;
   
   public class MyRunnable implements Runnable{    //具备了多线程操作能力
   
       @Override
       public void run() {
           for(int i=0;i<10;i++){
               System.out.println("MyRunnable.run()-----"+i);
           }    
       }
   }

线程状态

获取线程基本信息的方法

   ·线程操作的常用方法

　　static Thread currentThread()      返回目前正在执行的线程

package com.zqf.threadmethodproject;

public class TestThreadMethod {
    public static void main(String[] args) {
        Thread t = Thread.currentThread();    //获取当前正在执行的线程对象
        //toString()方法得到的内容为[线程名称，线程的优先级，线程组的名称]
        System.out.println(t.toString());
        
        //创建线程类的对象
        MyRunnable my =new MyRunnable();
        Thread t1 = new Thread(my);
        Thread t2 = new Thread(my);
        Thread t3 = new Thread(my);
        
        //启动线程
        t1.start();
        t2.start();
        t3.start();
        /**在Thread类中一定有一个静态变量int,用于统计创建线程的个数*/
    }
}
class MyRunnable implements Runnable{    //创建MyRunnable类实现Runnable接口

    @Override
    public void run() {
        Thread t = Thread.currentThread();
        System.out.println(t);
    }    
    
}

　　final String getName()　　返回线程的名称

　　final boolean isAlibe()　　判断线程是否处于活动状态

package com.zqf.threadmethodproject;

public class TestIsAliva {
    public static void main(String[] args) {
        //主线程
        MyThread my =new MyThread();
        System.out.println("线程my处于新生状态的线程是否处于活动状态");
        my.start();        //启动线程
        System.out.println("线程my处于就绪状态的线程是否处于活动状态："+my.isAlive()
        );
        //主线程中的循环
        for(int i=0;i<10;i++){
            System.out.println("-------"+Thread.currentThread().getName()+"---------->"+i);
        }    
        //主线程中的最后一句代码
        System.out.println("my线程是否处于活动状态："+my.isAlive());
    }
}
class MyThread extends Thread{
    public void run(){
        for(int i = 0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"---------->"+i);
        }
    }
}

多线程的安全问题

　　多线程的安全性问题：如300人买票5张票的问题

暂停线程执行sleep、yield、stop、join

 

 线程的优先级问题

package com.zqf.threadpriority;

public class Test {
    public static void main(String[] args) {
        System.out.println("最高优先级："+Thread.MAX_PRIORITY);
        System.out.println("最低优先级："+Thread.MIN_PRIORITY);
        System.out.println("默认优先级："+Thread.NORM_PRIORITY);
        //主线程的优先级
        Thread t = Thread.currentThread();
        System.out.println("获取主线程的优先级："+t.getPriority());
        Thread t2 = new Thread(new MyThread());
        System.out.println("新建的线程优先级："+t2.getPriority());
        /**
         * 优先级越高越有可能先被调用执行，但是不一定
         * */
        t2.setPriority(6);
        System.out.println("t2线程的优先级："+t2.getPriority());
        //t2.setPriority(100);    //由于超出了优先级，故会报错
    }
}
class MyThread implements Runnable{
    public void run() {
    }
}

线程同步 具体实现

   ·同步实现的方式

　　同步代码块

　　synchronized(obj){     }　　　　//obj称为同步监视器

   ·同步方法

死锁_死锁的解决办法

   ·产生死锁

package com.zqf.deadLockProject;

public class DeadLock extends Thread{
    private Object money;    //钱
    private Object water;    //水
    public boolean flag;    //标识持有对象锁
    public DeadLock(Object money, Object water) {
        super();
        this.money = money;
        this.water = water;
    }
    
    @Override
    public void run() {
        if(flag){    //true时，持有“钱”的锁
            synchronized(money){
                System.out.println("有钱，等水");
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                synchronized(water){}
                System.out.println("有水，等钱");
            }
        }else{
            synchronized(water){
                System.out.println("有水，等钱");
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                synchronized(money){
                    System.out.println("有钱，等水");
                }
            }
        }
    }
}

package com.zqf.deadLockProject;

public class Test {
    public static void main(String[] args) {
        //创建共享资源的对象
        Object money= new Object();
        Object water = new Object();
        //创建线程类的对象
        DeadLock d1 = new DeadLock(money,water);
        DeadLock d2 = new DeadLock(money,water);
        d1.flag= true;
        d2.flag= false;
        //启动线程
        d1.start();
        d2.start();
    }
}

   ·解决死锁

package com.zqf.deadLockProject;

public class DeadLock2 extends Thread{
    private Object money;    //钱
    private Object water;    //水
    public boolean flag;    //标识持有对象锁
    public DeadLock2(Object money, Object water) {
        super();
        this.money = money;
        this.water = water;
    }
    
    @Override
    public void run() {
        if(flag){    //true时，持有“钱”的锁
            synchronized(money){
                System.out.println("有钱，等水");
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                synchronized(water){}
                System.out.println("有水，等钱");
            }
        }else{
            synchronized(water){
                System.out.println("有水，等钱");
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
            }
            synchronized(money){
                System.out.println("有钱，等水");
            }
        }
    }
}

package com.zqf.deadLockProject;

public class DeadLock2 extends Thread{
    private Object money;    //钱
    private Object water;    //水
    public boolean flag;    //标识持有对象锁
    public DeadLock2(Object money, Object water) {
        super();
        this.money = money;
        this.water = water;
    }
    
    @Override
    public void run() {
        if(flag){    //true时，持有“钱”的锁
            synchronized(money){
                System.out.println("有钱，等水");
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                synchronized(water){}
                System.out.println("有水，等钱");
            }
        }else{
            synchronized(water){
                System.out.println("有水，等钱");
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
            }
            synchronized(money){
                System.out.println("有钱，等水");
            }
        }
    }
}

生产者消费者模式的实现

   ·生产者与消费者原理

   ·产生的问题

　　数据错乱