进程

一、自定义线程

进程 : 正在执行的程序称作为一个进程。 进程负责了内存空间的划分。

线程: 线程在一个进程 中负责了代码的执行,就是进程中一个执行路径,

多线程: 在一个进程中有多个线程同时在执行不同的任务。

疑问 :线程负责了代码 的执行,我们之前没有学过线程,为什么代码可以执行呢?
运行任何一个java程序,jvm在运行的时候都会创建一个main线程执行main方法中所有代码。

一个java应用程序至少有几个线程?
至少有两个线程, 一个是主线程负责main方法代码的执行,一个是垃圾回收器线程,负责了回收垃圾。

多线程的好处:
1. 解决了一个进程能同时执行多个任务的问题。
2. 提高了资源的利用率。

多线程 的弊端:
1. 增加cpu的负担。
2. 降低了一个进程中线程的执行概率。
3. 引发了线程安全 问题。
4. 出现了死锁现象。

创建线程的方式:
方式一
1. 自定义一个类继承Thread类。
2. 重写Thread类的run方法 , 把自定义线程的任务代码写在run方法中
3. 创建Thread的子类对象,并且调用start方法开启线程。

public class Demo1 extends Thread {
    
    @Override  //把自定义线程的任务代码写在run方法中。
    public void run() {
        for(int i  = 0 ; i < 100 ; i++){
            System.out.println("自定义线程:"+i);
        }
    }
    
    
    public static void main(String[] args) {
        //创建了自定义的线程对象。
        Demo1 d = new Demo1();
        //调用start方法启动线程
        d.start();
        
        for(int i  = 0 ; i < 100 ; i++){
            System.out.println("main线程:"+i);
        }
    }

    
    
}

疑问: 重写run方法的目的是什么? 
每个线程都有自己的任务代码,jvm创建的主线程的任务代码就是main方法中的所有代码, 自定义线程的任务代码就写在run方法中,自定义线程负责了run方法中代码。

注意: 一个线程一旦开启,那么线程就会执行run方法中的代码,run方法千万不能直接调用,直接调用run方法就相当调用了一个普通的方法而已并没有开启新的线程。

 

方式二

1. 自定义一个类实现Runnable接口。
2. 实现Runnable接口 的run方法,把自定义线程的任务定义在run方法上。
3. 创建Runnable实现类对象。
4. 创建Thread类 的对象,并且把Runnable实现类的对象作为实参传递。
5. 调用Thread对象 的start方法开启一个线程。

问题1: 请问Runnable实现类的对象是线程对象吗?
Runnable实现类的对象并 不是一个线程对象,只不过是实现了Runnable接口 的对象而已。
只有是Thread或者是Thread的子类才是线程 对象。

问题2: 为什么要把Runnable实现类的对象作为实参传递给Thread对象呢?作用是什么?
作用就是把Runnable实现类的对象的run方法作为了线程的任务代码去执行了。

推荐使用: 第二种。 实现Runable接口的。
原因: 因为java单继承 ,多实现的。

public class Demo3 implements Runnable{

    @Override
    public void run() {
        /*System.out.println("this:"+ this);
        System.out.println("当前线程:"+ Thread.currentThread());*/
        for(int i = 0 ; i < 100 ; i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
    
    public static void main(String[] args) {
        //创建Runnable实现类的对象
        Demo3 d = new Demo3();
        //创建Thread类的对象, 把Runnable实现类对象作为实参传递。
        Thread thread = new Thread(d,"狗娃");  //Thread类使用Target变量记录了d对象,
        //调用thread对象的start方法开启线程。
        thread.start();
        
        
        for(int i = 0 ; i < 100 ; i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
        
    } 
    
    /*
      Thread类 的run方法
      
     *  @Override
        public void run() {
            if (target != null) {
                target.run();  //就相当于Runnable实现类的对象的run方法作为了Thread对象的任务代码了。
            }
        }
    */
}

 

//需求:三个窗口卖50张票
class SaleTicket implements Runnable{
    
    int  num = 50; // 票数
    
    @Override
    public void run() {
        while(true){
            synchronized ("锁") {
                if(num>0){
                    System.out.println(Thread.currentThread().getName()+"售出了第"+ num+"号票");
                    num--;
                }else{
                    System.out.println("售罄了..");
                    break;
                }    
            }
        }        
    }
}


public class Demo4 {
    
    public static void main(String[] args) {
        //创建了一个Runnable实现类的对象
        SaleTicket saleTicket = new SaleTicket();
        //创建三个线程对象模拟三个窗口
        Thread thread1 = new Thread(saleTicket,"窗口1");
        Thread thread2 = new Thread(saleTicket,"窗口2");
        Thread thread3 = new Thread(saleTicket,"窗口3");
        //开启线程售票
        thread1.start();
        thread2.start();
        thread3.start();
        
        
    }

}

 

二、线程的生命周期

三、线程常用的方法

Thread(String name)   初始化线程的名字
setName(String name)    设置线程对象名
getName()    返回线程的名字

sleep()    线程睡眠指定的毫秒数。 静态的方法, 那个线程执行了sleep方法代码那么就是那个线程睡眠。

currentThread()    返回当前的线程对象,该方法是一个静态的方法, 注意: 那个线程执行了currentThread()代码就返回那个线程 的对象。

getPriority()    返回当前线程对象的优先级 默认线程的优先级是5
setPriority(int newPriority)   设置线程的优先级 虽然设置了线程的优先级,但是具体的实现取决于底层的操作系统的实现(最大的优先级是10 ,最小的1 , 默认是5)。

public class Demo3 extends Thread {
    
    public Demo3(String name){
        super(name); //调用了Thread类的一个 参数的构造方法。
    }
    
    
    @Override
    public void run() {
        /*System.out.println("this:"+ this);
        System.out.println("当前线程对象:" + Thread.currentThread());    */
        
        for (int i = 0; i < 100 ; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            
            
            /*try {
                Thread.sleep(100);  //为什么在这里不能抛出异常,只能捕获?? Thread类的run方法没有抛出异常类型,所以子类不能抛出异常类型。
            } catch (InterruptedException e) {
                e.printStackTrace();
            } */
        }
        
        
    }
    
    
    public static void main(String[] args) throws InterruptedException {
        //创建了一个线程对象
        Demo3 d = new Demo3("狗娃");
        d.setPriority(10); //设置线程 的优先级。 优先级的数字越大,优先级越高  , 优先级的范围是1~10
        d.start();
        
        for (int i = 0; i < 100 ; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
        
        /*
        System.out.println("自定义线程的优先级:"+d.getPriority());  //线程的优先级默认是5
        System.out.println("主线程的优先级:"+Thread.currentThread().getPriority());
        
        
        d.start();
        
        d.setName("铁蛋"); //setName设置线程的名字
        d.start(); //开启线程 
        
        Thread mainThread = Thread.currentThread();
        System.out.println("主线程的名字:"+ mainThread.getName());
    */
    }

}

 

四、线程安全问题

需求: 模拟3个窗口同时在售50张 票 。

问题1 :为什么50张票被卖出了150次?

出现 的原因: 因为num是非静态的,非静态的成员变量数据是在每个对象中都会维护一份数据的,三个线程对象就会有三份。

解决方案:把num票数共享出来给三个线程对象使用。使用static修饰。

问题2: 出现了线程安全问题 ?

线程 安全问题的解决方案:sun提供了线程同步机制让我们解决这类问题的。

 

出现线程安全问题的根本原因:
1. 存在两个或者两个以上 的线程对象,而且线程之间共享着一个资源。
2. 有多个语句操作了共享资源。


java线程同步机制的方式:
方式一:同步代码块

同步代码块的格式:

synchronized(锁对象){
需要被同步的代码...
}

 

同步代码块要注意事项:
1. 任意的一个对象都可以做为锁对象。
2. 在同步代码块中调用了sleep方法并不是释放锁对象的。
3. 只有真正存在线程安全问题的时候才使用同步代码块,否则会降低效率的。
4. 多线程操作的锁 对象必须 是唯一共享 的。否则无效。

需求: 一个银行账户5000块,两夫妻一个拿着 存折,一个拿着卡,开始取钱比赛,每次只能取一千块,要求不准出现线程安全问题。

public class demo extends Thread{
    
    static int sum = 5000;
    Object o = new Object();
    public demo(String name){
        super(name);
    }
    @Override
    public void run() {
        synchronized(o){
            while(true){
                if(sum>0){
                    System.out.println(this.currentThread().getName()+"取了1000块,还剩"+(sum-1000)+"元");
                    sum-=1000;
                }else{
                    System.out.println("取光了。。");
                    break;
                }
            }
        }
    
    }

    public static void main(String[] args) {
        demo husband = new demo("丈夫");
        demo wife = new demo("老婆");
        husband.start();
        wife.start();
        
        
    }
}

 


方式二:同步函数

同步函数就是使用synchronized修饰一个函数。

//需求: 一个银行账户5000块,两夫妻一个拿着 存折,一个拿着卡,开始取钱比赛,每次只能取一千块,要求不准出现线程安全问题。
        
*/

class BankThread extends Thread{
    
    static    int count = 5000;
    
    public BankThread(String name){
        super(name);
    }
    
    @Override  //
    public synchronized  void run() {
        while(true){
            synchronized ("锁") {                
                if(count>0){
                    System.out.println(Thread.currentThread().getName()+"取走了1000块,还剩余"+(count-1000)+"元");
                    count= count - 1000;
                }else{
                    System.out.println("取光了...");
                    break;
                }
            }
        }
    }    
    
    
    //静态的函数---->函数所属 的类的字节码文件对象--->BankThread.class  唯一的。
    public static synchronized  void getMoney(){
        
    }
    
}


public class Demo1 {

    public static void main(String[] args) {
        //创建两个线程对象
        BankThread thread1 = new BankThread("老公");
        BankThread thread2 = new BankThread("老婆");
        //调用start方法开启线程取钱
        thread1.start();
        thread2.start();
        
        
    }
    
}

 


同步函数要注意的事项 :
1. 如果是一个非静态的同步函数的锁 对象是this对象,如果是静态的同步函数的锁 对象是当前函数所属的类的字节码文件(class对象)。
2. 同步函数的锁对象是固定的,不能由你来指定 的。


推荐使用: 同步代码块。
原因:
1. 同步代码块的锁对象可以由我们随意指定,方便控制。同步函数的锁对象是固定 的,不能由我们来指定。
2. 同步代码块可以很方便控制需要被同步代码的范围,同步函数必须是整个函数 的所有代码都被同步了。

 

五、死锁

java中同步机制解决了线程安全问题,但是也同时引发死锁现象。

死锁现象出现 的根本原因:
1. 存在两个或者两个以上的线程。
2. 存在两个或者两个以上的共享资源。

死锁现象的解决方案: 没有方案。只能尽量避免发生而已。

死锁现象:

class DeadLock extends Thread{
    
    public DeadLock(String name){
        super(name);
    }
    
    
    public void run() {
        if("张三".equals(Thread.currentThread().getName())){
            synchronized ("遥控器") {
                System.out.println("张三拿到了遥控器,准备 去拿电池!!");
                synchronized ("电池") {
                    System.out.println("张三拿到了遥控器与电池了,开着空调爽歪歪的吹着...");
                }
            }
        }else if("狗娃".equals(Thread.currentThread().getName())){
            synchronized ("电池") { 
                System.out.println("狗娃拿到了电池,准备去拿遥控器!!");
                synchronized ("遥控器") {
                    System.out.println("狗娃拿到了遥控器与电池了,开着空调爽歪歪的吹着...");
                }
            }
            
        }    
    }
    
    
}

public class Demo2 {

    public static void main(String[] args) {
        DeadLock thread1 = new DeadLock("张三");
        DeadLock thread2 = new DeadLock("狗娃");
        //开启线程
        thread1.start();
        thread2.start();
        
        
    }
    
}

  

六、实现同步的几种方法:
synchronized、lock、wait()和notify()

 

synchronized与lock的区别:

1、synchronized是在JVM层面实现的,因此系统可以监控锁的释放与否,而ReentrantLock使用代码实现的,系统无法自动释放锁,需要在代码中finally子句中显式释放锁lock.unlock();

2、在并发量比较小的情况下,使用synchronized是个不错的选择,但是在并发量比较高的情况下,其性能下降很严重,此时ReentrantLock是个不错的方案。

 

 

 

 

 

 

 

 

posted @ 2016-02-26 17:23  Hsinwang  阅读(293)  评论(0编辑  收藏  举报