Java 多线程之启动编程例题与结果

Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。
进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守护线程都结束运行后才能结束。

多线程的基础知识

https://www.cnblogs.com/skywang12345/p/java_threads_category.html

如何获得线程ID

● 先获得一个 Thread 对象
● 这个对象有 getName, getId

启动线程

两种方式

1. extends Thread

public class xxx extends Thread{
    public void run() {方法}                                                  
    main函数{}
}

1.定义类继承Thread；
2.复写Thread类中的run方法；
3.启动线程：
启动前，需要 new 一个这个线程对象的实例,启动线程，调用start()方法来调用run方法。

2.implements Runable

public class xxx implements Runnable{            
    public void run() {方法}                                                                                
    main函数{
    }
}

1.定义类实现Runnable接口
2.覆盖Runnable接口中的run方法
3.通过Thread类建立线程对象。
4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
5.new 一个这个线程对象的实例,调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

例题

题目：

启动三个线程，依次从 1 打印 300 ，比如 线程1 打印 1 ， 线程2 打印 2，以此类推

大概思路：

● 三个线程并发，所以，在主进程里，要起三个线程
● 做一个同步资源，可以加锁的，这个同步资源需要放在主进程的，
● 实现三个线程的内部代码，三个线程，分别给三个名字，1，2，3。 1专门打印被三除 ，与1 ， 2专门打印被三除与2 ， 3专门打印被三除与 0
● 执行打印前，给对象加锁，
● 再 wait()
● 打印完成后，
● notify()

代码：

public class PrintNum {

    // 创建一个类的实例
    static Object obj = new Object();
    // 修饰被不同线程访问和修改的变量。
    static volatile int count = 1 ;
    static boolean judge = true ;
    final static int MAX_COUNT = 300 ;

    static class ThreadPrt extends Thread {

        public void run(){
            while (judge) {
                synchronized (obj) {
                    // 随机休眠时间
                    int sleep_num = (int) (Math.random() * 10);
                    try {
                        Thread.sleep(sleep_num);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    if (count % 3 == 1) {
                        System.out.println("线程1" + "    " + count);
                        count++;
                    }
                    if (count % 3 == 2) {
                        System.out.println("线程2" + "    " + count);
                        count++;
                    }
                    if (count % 3 == 0) {
                        System.out.println("线程3" + "    " + count);
                        count++;
                    }

                    obj.notifyAll();

                    // 到达最大数，退出
                    if (count > MAX_COUNT){
                        judge = false;
                        break ;
                    }

                    try {
                        System.out.println("=====哈哈=====");
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }


    public static void main(String[] args) throws Exception {
        ThreadPrt t1 = new ThreadPrt() ;
        // 设置名字
        t1.setName("线程1");
        t1.start();
        t1.sleep(100);
        ThreadPrt t2 = new ThreadPrt() ;
        t2.setName("线程2");
        t2.start();
        t2.sleep(100);
        ThreadPrt t3 = new ThreadPrt() ;
        t3.setName("线程3");
        t3.start();
        t3.sleep(100);


//        while ( count < 100 ){
//            System.out.println( "waitting ....");
//            try {
//                Thread.sleep(1000);
//                synchronized (obj) {
//                    // 主线程等待唤醒。
//                    System.out.println("main()  " +Thread.currentThread().getName() + " notifyAll()");
//                    obj.notify();
//                }
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//        }
    }
}

结果：