八.线程

/**
 * 线程
 * 线程有就绪，阻塞，运行三种状态
 * a.线程是轻量级的进程
 * b.线程没有独立的地址空间（内存空间）
 * c.线程是由进程创建的（寄生在进程）
 * d.一个进程可以拥有多个线程，这就是我们常说的多线程编程
 * f.线程的多种状态
 * 新建状态（new)--就绪状态（Runnable)--运行状态(Running)--阻塞状态（Blocked)--死亡状态（Dead)
 * 实现类的两种方法
 * a.继承Thread类，并重写run函数
 * b.实现Runnable接口，并重写run函数
 */
package com.test4;

public class day23 {
    public static void main(String []args) {
        //创建一个Cat对象
        Catt catt=new Catt();
        //启动线程 会启动run函数的运行
        catt.start();
    }
}

class Catt extends Thread{ //继承Thread类
    int time=0;    
    //重写run函数
        public void run() {
            while (true) {
                //休眠一秒 sleep会让线程进入Bllocked状态，并释放资源
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                time++;
                System.out.println(time);
                if (time==10) {
                    break;
                }
                System.out.println("哈喽啊树哥");
            }
            
        }
    
}

//用接口的方式实现单线程
package com.test4;

import java.io.IOException;
import java.nio.CharBuffer;

public class day24 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //创建一个对象
        Bread bread=new Bread();
        //创建一个Thread对象 并把创建的bread加入到Thread里面
        Thread d=new Thread(bread);
        //启动线程
        d.start();
    }
}
class Bread implements Runnable{

    int time=0;
    //重写run函数
    public void run() {
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            }
            time++;
            System.out.println(time+"哈喽啊树哥");
            if (time==10) {
                break;
            }
        }
    }
    
}

 

/**
 * 两个线程同时跑的案例
 */
package com.test4;

import java.sql.Time;



public class day25 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Pig pig=new Pig(5);
        Pan pan=new Pan(5);
        Thread t1=new Thread(pig);
        Thread t2=new Thread(pan);
        t1.start();
        t2.start();
        
        
    }

}
//打印
class Pig implements Runnable{
    int n=0;
    int times=0;
    public Pig(int n) {
        this.n=n;
    }
    public void run() {
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            }
            times++;
            System.out.println("我是一个线程在输出第"+times+"个哈喽啊树哥");
            if (times==n) {
                break;
            }
        }
    }
}
//做数学题
class Pan implements Runnable{
    int n=0;
    int times=0;
    int res=0;
    public Pan(int n) {
        this.n=n;
    }
    public void run(){
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            }
            res+=(++times);
            System.out.println("当前结果是："+res);
            if(times==n) {
                System.out.println("最后结果是："+res);
                break;
            }
        }
    }
}

 线程对象锁

/**
 * 线程并发所带来的安全问题
 * 如何解决并发问题
 * synchronized对象锁
 */

package com.test4;

public class day26 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Monkey mo=new Monkey();
        //新建三个线程
        Thread t1=new Thread(mo);
        Thread t2=new Thread(mo);
        Thread t3=new Thread(mo);
        //启动线程
        t1.start();
        t2.start();
        t3.start();
        
    }
 
}
class Monkey implements Runnable
{
    //定义1000个香蕉
    private int banana=100;

    @Override
    public void run() {
        // TODO Auto-generated method stub
        
        while (true) {
            
            //同步代码块this是对象本身
            synchronized (this) {

                //判断猴子吃香蕉
                if (banana>0) {
                    //Thread.currentThread().getName()这个可以查看是哪个线程在启动，对调试很有用
                    System.out.println(Thread.currentThread().getName()+"在吃第"+banana+"个香蕉");
                    try {
                        Thread.sleep(1000);
                    } catch (Exception e) {
                        // TODO: handle exception
                        e.printStackTrace();
                    }
                    //吃掉一个香蕉就减掉一根
                    banana--;
                    
                }else {
                    break;
                }
            }
        }
    }
}