Java知识点复习系列(3)

前言

这是利用课下时间对Java线程操作做题目进行巩固一下 , 在博客里记录一下自己的心得和笔记.希望可以和大家一起进步.

总结归类

1. 实例创建线程的两种方法
2. 查看当前线程是否存活
3. 获取当前线程名称
4. 设置线程优先级 , 并测试查看两个线程的执行顺序.
5. 获取线程ID值
6. 终止线程

7. 线程同步(生产者 消费者问题)

   这里使用两种方法实现 , 两种方法各有自己的好处和坏处.

8. 获取所有活着的线程

笔记代码

package Thread1;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * Java知识点复习(3)- 线程操作
 * @author Administrator
 *
 */
public class ThreadMain extends Thread {
    /**
     * 线程一 创建方法继承于Thread
     * @author Administrator
     *
     */
    public static class MyThread extends Thread{

    @Override
    public void run() {
        super.run();
        //线程执行的代码.
        while(true ) {
        System.out.println("Ghoset线程1 , 优先级为: " + this.getPriority() );
        try {
            Thread.sleep(1000 );
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        }

    }

    }


    public static class MyThread1 implements Runnable{

    int Priority;   

    public void  setVal(int Priority) {
        this.Priority = Priority;
    }

    @Override
    public void run() {
        while(true ) {
        System.out.println("Ghoset线程2,优先级为:" + Priority );
        try {
            Thread.sleep(1000 );
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        }
    }

    }


    /****************************************************************/
    //轮循机制实现生产者消费者问题
    /**
     * 生产的鸡蛋
     *
     */
    public class Egg{
    private int id;     //生成的线程编号 , 起到一个观察的作用
    public Egg(int id  ) {
        this.id = id;
    }
    @Override
    public String toString() {
        return "Egg("+id+")";
    }   




    }

    /**
     * 生产者-母鸡
     * 在5-10秒之间生产出一个鸡蛋(add)
     */
    public class Hen extends Thread{
    public List<Egg> basket;    // 生产的鸡蛋放在这里面

    public Hen(List<Egg> basket ) {
        this.basket = basket;
    }

    @Override
    public void run() {
        Random r = new Random();
        int count = 0;

        while(true ) {
        Egg egg = new Egg(++count );        //从1开始
        //设置锁 , 防止我在生产时有人访问.
        synchronized (basket ) {            //记住 , 我们写锁 , 只要将需要锁的放在锁里面 . 不然会浪费了
            basket.add(egg );
        }
        System.out.println("生产了:" + egg );
        //设置生产时间
        try {
            long time = r.nextInt(5 ) + 5;      //5-10之间
            Thread.sleep(time * 1000 );     //以毫秒为单位 

        }catch(Exception e ) {
            e.printStackTrace();
        }



        }

    }





    }



    /**
     * 消费者-小孩
     * 每1秒去观察是否生产鸡蛋 ,  如果生产 , 则吃掉(remove)
     */
    public class Boy extends Thread{
    List<Egg > basket ;
    public Boy(List<Egg > basket ){
        this.basket = basket;
    }
    @Override
    public void run() {
        Random r = new Random();

        while(true ) {
        Egg egg = null;
        synchronized (basket ) {
            if(basket.size() > 0 ) {            //里面有鸡蛋
            egg = basket.remove(0 );    //直接给删除了 , 但是我们获取删除的那个鸡蛋
            }
            //打印输出
            if(egg !=null ) {
            System.out.println("\t吃了:" + egg );
            }

            try {
            Thread.sleep(1000 );
            }catch(Exception e ) {
            e.printStackTrace();
            }


        }
        }

    }





    }
    //轮循机制
    public void test() {
    List<Egg> basket = new ArrayList<>();
    Hen hen = new Hen(basket );
    Boy boy = new Boy(basket );

    hen.start();
    boy.start();

    }
    /****************************************************************/
    public class Book{
    private int id;
    public Book(int id ) {
        this.id = id;
    }
    @Override
    public String toString() {
        return "(Book ID:"  + this.id + ")";
    }


    }
    /**
     * 书籍工厂- 生产者
     * 每3-5秒生产一本书籍
     */
    public class BookFactory extends Thread {
    List<Book > bookStore ;         //书店
    public BookFactory(List<Book > bookStore ) {
        this.bookStore = bookStore;
    }
    @Override
    public void run() {
        int count = 0;
        while(true ) {
        Book book = new Book(++count );
        synchronized (bookStore  ) {
            bookStore.add(book );
            bookStore.notify();             //发送信息

        }

        System.out.println("生产了:" + book  );

        try {
            long time = new Random().nextInt(3 ) + 3;
            Thread.sleep(time * 1000 );

        }catch(Exception e ) {
            e.printStackTrace();
        }

        }




    }



    }

    /**
     * 人员 - 消费者
     * 它一生产 , 立马就人买下这本书籍
     */
    public class People extends Thread{
    List<Book > bookStore ;     //书店
    public People(List<Book > bookStore ) {
        this.bookStore = bookStore;
    }

    @Override
    public void run() {
        while(true ) {
        Book book = null;
        synchronized (bookStore ) {
            try {
            bookStore.wait();               //直接进行等待.
            } catch (InterruptedException e) {
            e.printStackTrace();
            }

            if(bookStore.size() > 0 ) {
            book = bookStore.remove(0);
            }

        }

        if(book != null ) {
            System.out.println("\t购买了:" + book );
        }

        }
    }

    }



    //通知机制
    public void test1() {
    List<Book > bookStore = new ArrayList<Book >();
    BookFactory factory = new BookFactory(bookStore );
    People people = new People(bookStore );
    factory.start();
    people.start();
    }





    /****************************************************************/
    /**
     * 主方法
     * @param args
     */

    public static void main(String[] args) {
/*  //0.创建线程的丙种方法
        //继承于Thread类
        //实现Runnable接口

    //1.查看当前线程是否存活
    Thread t1 = new MyThread(); 
    t1.start();//启用线程
    t1.setName("Ghoset" );//设置线程名称
    System.out.println("当前线程的状态:" + t1.isAlive() );


    //2.获取当前线程名称
    Thread currThread = Thread.currentThread();
    System.out.println("当前线程名称为:" + currThread.getName() );

    //3.设置线程优先级 , 并测试查看两个线程的执行顺序.
    MyThread1 mt = new MyThread1();
    Thread t2 = new Thread(mt );
    t2.setPriority(1 );     //设置优先级为5
    mt.setVal(t2.getPriority() );
    t2.start();

    //4.获取线程ID值
    System.out.println("线程1的ID为:" + t1.getId() );
    System.out.println("线程2的ID为:" + t2.getId() );


    //5.终止线程
    //终止线程的话一定要将线程睡眠时间设置久一点 , 不然无法关闭
    try {
    t1.interrupt();
    t2.interrupt();
    }catch(Exception e ) {
        e.printStackTrace();
    }*/


    //6.线程同步(生产者 消费者问题)
    //轮循机制
    ThreadMain t = new ThreadMain();
    t.setName("Ghoset" );                   //给这个线程设置名称 
    t.start();
    //t.test();
    //通知机制
    //t.test1();

    //7.获取所有线程
    ThreadGroup group = Thread.currentThread().getThreadGroup();    //获取当前线程组

    Thread[] thread = new Thread[Thread.activeCount() ];
    group.enumerate(thread );   //这里直接写Thread.enumXXXX也可以
    for(Thread v : thread ) {
        System.out.println("当前线程名为:" + v.getName() );
    }


    }

}