Java多线程基础（二）

旧城等待， 2022-06-16 08:39 128阅读 0赞

Java多线程理解

一、常用方法

1、join（）方法，让一个线程等待另一个线程执行完之后再执行。例如：A线程执行体中执行B线程的join方法，那么需要等到B线程执行完毕之后再执行A线程。

示例：

public class MyRunnable implements Runnable{
    	private boolean flag = false;
    	@Override
    	public void run() {
    		for(int i = 0 ; i < 100 && !flag ; i++){
    			System.out.println(Thread.currentThread().getName()+"---"+i);
    		}
    	}
    }

public class Test extends Thread{
    	public static void main(String[] args) throws InterruptedException, ExecutionException {		
    		MyRunnable myRunnable = new MyRunnable();
    		Thread thread = new Thread(myRunnable);
    		for(int i = 0 ; i < 100 ; i++){
    			System.out.println(Thread.currentThread().getName()+"--"+i);
    			if(i == 30){
    				thread.start();
    				thread.join();
    			}
    		}
    	}
    }

当i== 30时，在主线程中插入thread线程，直到thread线程执行完毕，主线程才开始执行。  
2、sleep（）：让线程暂停执行指定的时间。由于线程不是出于就绪状态，在指定时间之内，线程不能执行。特殊应用：当new一个线程并调用start()方法之后，线程需要等待某个时间获取CPU时间片才能执行，如果希望这个线程立即执行，可以使用sleep(1),当然这个立即执行的线程不一定是多线程中的哪一个。

public class Test extends Thread{
    	public static void main(String[] args) throws InterruptedException, ExecutionException {		
    		MyRunnable myRunnable = new MyRunnable();
    		Thread thread1 = new Thread(myRunnable);
    		thread1.setName("A");
    		Thread thread2 = new Thread(myRunnable);
    		thread2.setName("B");
    		Thread thread3 = new Thread(myRunnable);
    		thread3.setName("C");
    		for(int i = 0 ; i < 100 ; i++){
    			System.out.println(Thread.currentThread().getName()+"---"+i);
    			if(i==30){
    				thread1.start();
    				Thread.sleep(1);
    			}
    			if(i==40){
    				thread2.start();
    				Thread.sleep(1);
    			}
    			if(i==50){
    				thread3.start();
    				Thread.sleep(1);
    			}
    			
    		}
    	}
    }

class MyRunnable implements Runnable {
    
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + " " + i);
            }
        }
    }

3、后台线程

概念/目的：后台线程主要是为其他线程（相对可以称之为前台线程）提供服务，或“守护线程”。如JVM中的垃圾回收线程。

生命周期：后台线程的生命周期与前台线程生命周期有一定关联。主要体现在：当所有的前台线程都进入死亡状态时，后台线程会自动死亡(其实这个也很好理解，因为后台线程存在的目的在于为前台线程服务的，既然所有的前台线程都死亡了，那它自己还留着有什么用...伟大啊 ! !)。

设置后台线程：调用Thread对象的setDaemon(true)方法可以将指定的线程设置为后台线程。

判断线程是否是后台线程：调用thread对象的isDeamon()方法。

注： main 线程默认是前台线程，前台线程创建中创建的子线程默认是前台线程，后台线程中创建的线程默认是后台线程。调用 setDeamon(true) 方法将前台线程设置为后台线程时，需要在 start() 方法调用之前。前天线程都死亡后， JVM 通知后台线程死亡，但从接收指令到作出响应，需要一定的时间。

public class Test extends Thread{
    	public static void main(String[] args) throws InterruptedException, ExecutionException {		
    		MyRunnable myRunnable = new MyRunnable();
    		Thread thread = new Thread(myRunnable);
    		
    		for(int i = 0 ; i < 10 ; i++){
    			System.out.println(Thread.currentThread().getName()+"--"+i);
    			if(i == 3){
    				thread.setDaemon(true);
    				thread.start();
    			}
    		}
    	}
    }

public class MyRunnable implements Runnable{
    	private boolean flag = false;
    	@Override
    	public void run() {
    		for(int i = 0 ; i < 10000 && !flag ; i++){
    			System.out.println(Thread.currentThread().getName()+"---"+i);
    		}
    	}
    	public void stoped(){
    		this.flag = true;
    	}
    }

执行结果：

main--0
    main--1
    main--2
    main--3
    main--4
    main--5
    main--6
    main--7
    main--8
    main--9
    Thread-0---0
    Thread-0---1
    Thread-0---2
    Thread-0---3
    Thread-0---4
    Thread-0---5
    Thread-0---6
    Thread-0---7
    Thread-0---8
    Thread-0---9

4、常用的快速终止线程的方法

一般线程状态分成就绪状态、运行状态、死亡状态。

就绪状态转换成运行状态：线程得到处理器资源

运行状态转换成就绪窗台：此线程主动执行yeild()方法或者再运行过程中失去处理器资源。

运行状态转成死亡状态： 线程执行体执行结束或者发生了异常。

此处需要特别注意的是：当调用线程的yield()方法时，线程从运行状态转换为就绪状态，但接下来CPU调度就绪状态中的哪个线程具有一定的随机性，因此，可能会出现A线程调用了yield()方法后，接下来CPU仍然调度了A线程的情况。

由于实际的业务需要，常常会遇到需要在特定时机终止某一线程的运行，使其进入到死亡状态。目前最通用的做法是设置一boolean型的变量，当条件满足时，使线程执行体快速执行完毕。如：

public class Test extends Thread{
    	public static void main(String[] args) throws InterruptedException, ExecutionException {		
    		MyRunnable myRunnable = new MyRunnable();
    		Thread thread = new Thread(myRunnable);
    		for(int i = 0 ; i < 10000000 ; i++){
    			if(i==3){
    				thread.start();
    			}
    			if(i == 400000){
    				myRunnable.stoped();
    			}
    		}
    	}
    }

二、对象及变量的并发访问

1、（1）方法内变量是线程安全的

public class SelfNum  {
    
    	public void addI(String name){
    		int num = 0;
    		if("a".equals(name)){
    			num = 100;
    			System.out.println(ThreadA.currentThread().getName()+",a set over");
    			try {
    				Thread.sleep(1000);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    		if("b".equals(name)){
    			num = 200;
    			System.out.println(ThreadA.currentThread().getName()+",b set over");
    			try {
    				Thread.sleep(1000);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    		System.out.println(ThreadA.currentThread().getName()+",当前num值是："+num);
    	}
    }

（2）实例变量非线程安全

public class SelfNum  {
    
    	private int num = 0;
    	public void addI(String name){
    		if("a".equals(name)){
    			num = 100;
    			System.out.println(ThreadA.currentThread().getName()+",a set over");
    			try {
    				Thread.sleep(1000);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    		if("b".equals(name)){
    			num = 200;
    			System.out.println(ThreadA.currentThread().getName()+",b set over");
    			try {
    				Thread.sleep(1000);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    		System.out.println(ThreadA.currentThread().getName()+",当前num值是："+num);
    	}
    }

测试：

public class MainTest {
    
    	public static void main(String[] args) {
    		SelfNum selfNum = new SelfNum();
    		ThreadA threadA = new ThreadA(selfNum);
    		ThreadB threadB = new ThreadB(selfNum);
    		
    		threadA.start();
    		threadB.start();
    	}
    }

第一种情况结果：

Thread-0,a set over
    Thread-1,b set over
    Thread-1,当前num值是：200
    Thread-0,当前num值是：100

第二种情况结果：

Thread-0,a set over
    Thread-1,b set over
    Thread-0,当前num值是：200
    Thread-1,当前num值是：200