Java多线程学习

最新推荐文章于 2022-04-13 17:00:02 发布

java_reduce

最新推荐文章于 2022-04-13 17:00:02 发布

阅读量148

点赞数

在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口.

1、继承Thread类

public class MyThread1 extends Thread {
	private String name;
	public MyThread1(String name){
		this.name = name;
	}
	@Override
	public void run(){
		for(int i = 1;i<=8;i++){
			System.out.println(name+"第几次："+i);
			try {  
                sleep((int) Math.random() * 10);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
		}
		
	}	
	public static void main(String[] args) {		
		MyThread1 A = new MyThread1("A");
		MyThread1 B = new MyThread1("B");
		A.start();
		B.start();		
	}

}

运行结果：A第几次：1
B第几次：1
A第几次：2
B第几次：2
B第几次：3
B第几次：4
B第几次：5
B第几次：6
B第几次：7
B第几次：8
A第几次：3
A第几次：4
A第几次：5
A第几次：6
A第几次：7
A第几次：8

再运行一次，发现结果是不一样的，说明运行的顺序是乱的，其实是两个线程在互相争夺cpu。

程序启动运行main时候，java虚拟机启动一个进程，主线程main在main()调用时候被创建。随着调用两个线程对象的start方法，另外两个线程也启动了，这样，整个应用就在多线程下运行。

注意：调用start方法后并不是立马执行多线程代码，而是将该线程变为可运行状态（Runable）,什么时间运行由操作系统决定。

Thread.sleep()方法调用目的是不让当前线程独自霸占该进程说获取的cpu资源，以留出一定时间给其他线程执行的机会。实际上所有的多线程代码执行顺序都是不确定的，每次执行的结果都是随机的。

但是start方法重复调用的话，会出现java.lang.IllegalThreadStateException异常。

Exception in thread "main" A第几次：1
A第几次：2java.lang.IllegalThreadStateException
at java.lang.Thread.start(Thread.java:705)
at thread.MyThread1.main(MyThread1.java:23)

A第几次：3
A第几次：4
A第几次：5
A第几次：6
A第几次：7
A第几次：8

2、实现Runable接口.

class Thread2 implements Runnable{  
    private String name;  
  
    public Thread2(String name) {  
        this.name=name;  
    }  
  
    @Override  
    public void run() {  
          for (int i = 0; i < 5; i++) {  
                System.out.println(name + "运行  :  " + i);  
                try {  
                    Thread.sleep((int) Math.random() * 10);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
          
    }  
      
}  
public class Main {  
  
    public static void main(String[] args) {  
        new Thread(new Thread2("C")).start();  
        new Thread(new Thread2("D")).start();  
    }  
  
}

运行结果：

C运行 : 0
D运行 : 0
D运行 : 1
C运行 : 1
C运行 : 2
C运行 : 3
D运行 : 2
C运行 : 4
D运行 : 3
D运行 : 4

说明：

Thread2类通过实现Runnable接口，使得该类有了多线程类的特征。run（）方法是多线程程序的一个约定。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。

在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是扩展Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

3、线程的状态。

①、新建状态（new）：新创建了一个对象。

②、就绪状态（runnable）:调用start方法后，该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。

③、运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。

④、阻塞状态（Blocked）：

阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。(wait会释放持有的锁)

（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。

（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。（注意,sleep是不会释放持有的锁）。

⑤、死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

常用的一些方法：

线程睡眠：Thread.sleep(long millis)方法，使线程转到阻塞状态。millis参数设定睡眠的时间，以毫秒为单位。当睡眠结束后，就转为就绪（Runnable）状态。sleep方法不会释放锁。

线程等待：Object类中的wait()方法，导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 唤醒方法。这个两个唤醒方法也是Object类中的方法，行为等价于调用 wait(0) 一样。该方法会释放线程锁。

线程让步：Thread.yield() 方法，暂停当前正在执行的线程对象，把执行机会让给相同或者更高优先级的线程。

线程加入：join()方法，等待其他线程终止。在当前线程中调用另一个线程的join()方法，则当前线程转入阻塞状态，直到另一个进程运行结束，当前线程再由阻塞转为就绪状态。

线程唤醒：Object类中的notify()方法，唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。类似的方法还有一个notifyAll()，唤醒在此对象监视器上等待的所有线程。

Obj.wait()，与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait,与notify是针对已经获取了Obj锁进行操作，从语法角度来说就是Obj.wait(),Obj.notify必须在synchronized(Obj){...}语句块内。从功能上来说wait就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。相应的notify()就是对对象锁的唤醒操作。但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作。Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于Object.wait()在释放CPU同时，释放了对象锁的控制。

建立三个线程，A线程打印10次A，B线程打印10次B,C线程打印10次C，要求线程同时运行，交替打印10次ABC。这个问题用Object的wait()，notify()就可以很方便的解决。代码如下：

public class MyThreadPrinter2  implements Runnable{
	public String name;
	public Object prev;
	public Object self;
	public MyThreadPrinter2(String name,Object prev,Object self) {
		this.name = name;
		this.prev = prev;
		this.self = self;
	}
	@Override
	public void run() {
		int count = 10;
		while(count>0) {
			synchronized (prev) {
				synchronized (self) {
				    System.out.print(name);     
                    count--; 
					self.notify();
				}
				try {
					prev.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
			}
		}
		
	}
	public static void main(String[] args) throws Exception {
		
		Object a = new Object();     
		Object b = new Object();     
		Object c = new Object();     
		MyThreadPrinter2 pa = new MyThreadPrinter2("A", c, a);     
		MyThreadPrinter2 pb = new MyThreadPrinter2("B", a, b);     
		MyThreadPrinter2 pc = new MyThreadPrinter2("C", b, c);                               
	    new Thread(pa).start();  
	    Thread.sleep(100);  //确保按顺序A、B、C执行  
	    new Thread(pb).start();  
	    Thread.sleep(100);    
	    new Thread(pc).start();     
	    Thread.sleep(100);    		
	}

}

输出结果：

ABCABCABCABCABCABCABCABCABCABC

先来解释一下其整体思路，从大的方向上来讲，该问题为三线程间的同步唤醒操作，主要的目的就是ThreadA->ThreadB->ThreadC->ThreadA循环执行三个线程。为了控制线程执行的顺序，那么就必须要确定唤醒、等待的顺序，所以每一个线程必须同时持有两个对象锁，才能继续执行。一个对象锁是prev，就是前一个线程所持有的对象锁。还有一个就是自身对象锁。主要的思想就是，为了控制执行的顺序，必须要先持有prev锁，也就前一个线程要释放自身对象锁，再去申请自身对象锁，两者兼备时打印，之后首先调用self.notify()释放自身对象锁，唤醒下一个等待线程，再调用prev.wait()释放prev对象锁，终止当前线程，等待循环结束后再次被唤醒。运行上述代码，可以发现三个线程循环打印ABC，共10次。程序运行的主要过程就是A线程最先运行，持有C,A对象锁，后释放A,C锁，唤醒B。线程B等待A锁，再申请B锁，后打印B，再释放B，A锁，唤醒C，线程C等待B锁，再申请C锁，后打印C，再释放C,B锁，唤醒A。看起来似乎没什么问题，但如果你仔细想一下，就会发现有问题，就是初始条件，三个线程按照A,B,C的顺序来启动，按照前面的思考，A唤醒B，B唤醒C，C再唤醒A。但是这种假设依赖于JVM中线程调度、执行的顺序。

3.实现Callable接口。

public class ThreadCallable implements Callable<String>{
	@Override
	public String call() throws Exception {
		System.out.println("我的线程执行了");
		return "线程的返回值";
	}	
	public static void main(String[] args) throws Exception {
		ThreadCallable threadCallable = new ThreadCallable();
        //包装线程执行目标，因为Thread的构造函数只能接受Runnable接口的实现类，而FutureTask类实现了Runnable接口
		FutureTask<String> task = new FutureTask<>(threadCallable);
		Thread thread = new Thread(task);
		thread.start();
		String result = null;
		try {
			result = task.get();
		}catch(Exception e) {
			throw e;
		}
		System.out.println(result);			
	}
}

优点：扩展性好、支持多线程处理同一份资源、具备返回值以及可以抛出受检查异常

缺点：相较于实现Runnable接口的方式，较为繁琐

小结：
方式一和方式二本质上都是通过实现Runnable接口并重写run()方法，将接口实现类的实例传递给Thread线程类来执行线程体（run()方法中的实现），这里将Runnable接口实现类的实例作为线程执行目标，供线程Thread实例执行；对于方式三，其实也是这样的，由于Thread类只能执行Runnable接口实现类的执行目标，所以需要对Callable接口的实现类进行包装，包装成Runnable接口的实现类（通过实现了Runnable接口的FutureTask类进行包装），从而使得Thread类能够接收Callable接口实现类的实例，这里使用了适配器模式！

java_reduce

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java多线程学习

在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口.1、继承Thread类public class MyThread1 extends Thread { private String name; public MyThread1(String name){ this.name = name; } @Override publi...
复制链接

扫一扫