Java中并发编程基础（上）

Java中并发编程基础（上）

*Java语言支持多线程的程序设计，多线程的程序设计具有广泛的应用

• 线程是进程中一个单独的顺序控制流
• 单线程：整个程序中只有一个执行线索，作为单个顺序控制流，线程必须在运行的程序中得到自己运行的资源
• 多线程：单个的程序可以同时运行多个不同的线程完成不同的任务
• 多线程与多任务不同，多任务是操作系统下可以同时运行多个程序，多线程是在一个程序中有多个同时运行的控制流
• 要实现多线程，要先创建线程对象
• 构建线程任务有两种方法：
• 1.实现Runnable接口，并实现它的run()方法
• 2.继承Thread类并覆盖它的run()方法

public class RunnableDemo implements Runnable {

    @Override
    public void run() {
        for(int i=0; i<100; i++){
            System.out.println(Thread.currentThread().getName()+" = " + i) ; //输出当前执行线程对象的名称
            try{
                //使当前线程睡眠一段时间
                Thread.sleep((int)(Math.random() * 100)) ;
            }catch(InterruptedException e){ //捕获中断异常
            }
        }
        System.out.println(Thread.currentThread().getName() + " 结束" ) ;
    }
    public static void main(String[] args){
        RunnableDemo task = new RunnableDemo() ; //创建类的实例化对象
        Thread thread1 = new Thread(task,"线程A") ;
        Thread thread2 = new Thread(task,"线程B") ;
        thread1.start() ;
        thread2.start() ;
    }
}

• 通过继承Thread类，并覆盖run()方法，可以使用该类的实例作为线程的任务对象

public class ThreadDemo extends Thread {
    public ThreadDemo(String name){
        super(name) ; //访问父类的名称
    }
    public void run(){
        for(int i=0; i<100; i++){
            System.out.println(getName() + " = " + i) ; //s输出对应线程名
            try{
                Thread.sleep((int)(Math.random() * 100)) ; //设置线程睡眠时间
            }catch(InterruptedException e){ //捕获中断异常

            }
        }
        System.out.println(getName() + " 结束") ; //输出线程结束的名称
    }
    public static void main(String[] args){
        Thread thread1 = new ThreadDemo("线程A") ;
        Thread thread2 = new ThreadDemo("线程B") ;
        thread1.start() ;
        thread2.start() ;
    }
}

• 当Java程序的main()方法开始运行时，Java虚拟机就启动一个线程
• 该线程负责启动其它线程，因此称为主线程

public class MainThreadDemo {
    public static void main(String[] args){
        Thread t = Thread.currentThread() ; //返回当前的主线程对象
        System.out.println(t) ; //输出线程对象,包括线程名，优先级，线程组名
        System.out.println(t.getName()) ; //输出线程对象的名称
        t.setName("MyThread") ; //设置线程对象的名称
        System.out.println(t) ;
    }
}

• 一个线程从创建到结束一般经历6个状态，每个线程 都有一个优先级，当有多个线程处于可运行状态时
• 线程调度器根据现成的优先级调度线程运行，可以设置和返回线程的优先级
• 一般地，只有当前线程停止或由于某种原因阻塞，较低优先级的线程才有机会运行

public class ThreadPriorityDemo {
    //静态内部类
    static class CounterThread extends Thread{
        public void run(){
            int count = 0 ;
            while(true){
                try{
                    sleep(1) ; //睡眠
                    }catch(InterruptedException e){
                }
                if(count == 1000){
                    break ;
                }
                System.out.println(getName() + ":" + count++) ;
            }
        }
    }
    public static void main(String[] args){
        CounterThread thread1 = new CounterThread() ; //实例化线程对象
        CounterThread thread2 = new CounterThread() ;
        thread1.setPriority(1) ; //设置线程优先级
        thread2.setPriority(10) ; //设置线程优先级
        thread1.start() ; //启动线程
        thread2.start() ;
    }
}

• 控制线程结束
• 通常，在线程的任务中通过一个循环控制线程的结束，如果run()方法是一个
• 不确定的循环，则一般设置一个标志变量，在程序中通过改变标志变量的值实现结束线程
• 如下程序所示

import java.time.LocalDateTime;
public class ThreadStop {
    //静态内部类
    static class MyTimer implements Runnable{
        boolean flag = true ;
        @Override
        public void run() {
            while(flag){
                System.out.println("" + LocalDateTime.now() + "...") ;
                try{
                    Thread.sleep(1000) ; //线程睡眠时间为1秒
                }catch(InterruptedException e){
                }
            }
            System.out.println("" + Thread.currentThread().getName() + " 结束")  ;
        }
        public void stopRun(){ //结束线程运行的方法
            flag = true ;
        }
    }
    public static void main(String[] args){
        MyTimer myTimer = new MyTimer() ;
        Thread thread = new Thread(myTimer) ;
        thread.setName("Timer") ;
        thread.start() ;
        for(int i=0; i<100; i++){
            System.out.println("" + i) ;
            try{
                Thread.sleep(100) ;
            }catch(InterruptedException e){
            }
        }
        myTimer.stopRun() ; //结束线程
    }
}