Java多线程

Java多线程核心技术

最新推荐文章于 2024-12-01 23:53:39 发布

原创最新推荐文章于 2024-12-01 23:53:39 发布 · 272 阅读

0 ·

CC 4.0 BY-SA版权

java 专栏收录该内容

3 篇文章

订阅专栏

一、Java中多线程的三种实现方式

1、继承Thread类实现多线程

（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。

（2）创建Thread子类的实例，即创建了线程对象。

（3）调用线程对象的start()方法来启动该线程。注意必须通过start方式开启线程，如果直接调用run方法，那么它只是一个普通的方法，不会开启一个线程。

简单实现：

public class Demo1 extends Thread {
	@Override  //把自定义线程的任务代码写在run方法中。
	public void run() {
		for(int i  = 0 ; i < 100 ; i++){
			System.out.println("自定义线程："+i);
		}
	}
	public static void main(String[] args) {
		//创建了自定义的线程对象。
		Demo1 d = new Demo1();
		//调用start方法启动线程
		d.start();
		for(int i  = 0 ; i < 100 ; i++){
			System.out.println("main线程："+i);
		}
	}
}

2、通过Runnable接口创建线程

（1）定义一个实现Runnable接口的类。

（2）重写Runnable接口中的run方法，就是将线程运行的代码放入在run方法中。

（3）通过实现了Runnable接口的类创建一个对象。

（4）将Runnable接口的子类对象作为实际参数（即第三部中创建的），传递给Thread类构造方数，从而创建一个Thread类对象。

（5）调用Thread类的start方法开启线程，并调用Runable接口子类run方法。

代码如下：

public class Demo1 {
	public static void main(String[] args) {
		MyRun my = new MyRun();
		Thread t1 = new Thread(my);
		t1.start();
		for (int i = 0; i < 200; i++) {
			System.out.println("main:" + i);
		}
	}
}
class MyRun implements Runnable {
	public void run() {
		for (int i = 0; i < 200; i++) {
			System.err.println("MyRun:" + i);
		}
	}
}

3、通过Callable和Future创建线程

（1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。

（2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。

（4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

import java.util.concurrent.Callable;  
import java.util.concurrent.ExecutionException;  
import java.util.concurrent.FutureTask;  
public class CallableThreadTest implements Callable<Integer>  
{  
    public static void main(String[] args)  
    {  
        CallableThreadTest ctt = new CallableThreadTest();  
        FutureTask<Integer> ft = new FutureTask<>(ctt);  
        for(int i = 0;i < 100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);  
            if(i==20)  
            {  
                new Thread(ft,"有返回值的线程").start();  
            }  
        }  
        try  
        {  
            System.out.println("子线程的返回值："+ft.get());  
        } catch (InterruptedException e)  
        {  
            e.printStackTrace();  
        } catch (ExecutionException e)  
        {  
            e.printStackTrace();  
        }  
  
    }  
    @Override  
    public Integer call() throws Exception  
    {  
        int i = 0;  
        for(;i<100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" "+i);  
        }  
        return i;  
    }  
}

二、线程状态

新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();

就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；

运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；

阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种：

1.等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；

2.同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；

3.其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

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

三、线程同步与线程死锁

每个java对象都有一个锁对象.而且只有一把钥匙。使用多线程可能会产生安全性问题，当多条语句在操作多个线程共享数据时，一个线程对多条语句执行了一部分，还没执行完，另一个线程参与进来执行，会导致共享数据的错误，这种问题就可以用锁（synchronized）来解决。比如用多线程模拟多个卖票窗口，每个线程代表一个窗口，进行卖票。如果不加锁同步，由于实际执行过程中线程的不断切换，可能会产生卖重复票，票卖光后还能卖等bug。下面是示例代码：

class SaleTicket implements Runnable{
	int  num = 50; // 票数
	@Override
	public void run() {
		while(true){
			synchronized ("锁") {
				if(num>0){
					System.out.println(Thread.currentThread().getName()+"售出了第"+ num+"号票");
					num--;
				}else{
					System.out.println("售罄了..");
					break;
				}	
			}
		}		
	}
}
public class Demo4 {
	public static void main(String[] args) {
		//创建了一个Runnable实现类的对象
		SaleTicket saleTicket = new SaleTicket();
		//创建三个线程对象模拟三个窗口
		Thread thread1 = new Thread(saleTicket,"窗口1");
		Thread thread2 = new Thread(saleTicket,"窗口2");
		Thread thread3 = new Thread(saleTicket,"窗口3");
		//开启线程售票
		thread1.start();
		thread2.start();
		thread3.start();
	}
}

使用线程同步的弊端：

1. 线程每次进入同步代码块或同步函数都要判断锁，浪费资源，影响效率
2. 可能出现死锁现象，多发生在一个同步代码块或同步函数中嵌套另一个同步函数或同步代码块，且2个同步上使用不同的锁。即同步中嵌套同步而锁不同就容易引发死锁。

产生死锁的情况如：

1：两个任务以相反的顺序申请两个锁，死锁就可能出现

2：线程T1获得锁L1，线程T2获得锁L2，然后T1申请获得锁L2，同时T2申请获得锁L1，此时两个线程将要永久阻塞，死锁出现

在使用多线程synchronized时，需要注意对死锁的预防与避免。

四、线程间通信

线程间通信是指一个线程完成了自己的任务时，要通知另外一个线程去完成另外一个任务。这里主要说一下线程通信中的wait/notify机制。

wait(): 等待如果线程执行了wait方法，那么该线程会进入等待的状态，等待状态下的线程必须要被其他线程调用notify方法才能唤醒。
notify()：唤醒唤醒线程池等待线程其中的一个。
notifyAll() : 唤醒线程池所有等待线程。

这三个方法必须由同步监视器对象来调用，这可分成两种情况：

对于使用synchronized修饰的同步方法，因为该类的默认实例是(this)就是同步监视器，所以可以直接调用这三使用个方法。
对于synchronized修饰的同步代码块，同步监视器是synchronized括号里的对象，所以必须使用该对象调用这三个方法。

下面是生产者消费者问题当中使用这几个方法的示例：

//产品类
class Product{
	
	String name;  //名字
	
	double price;  //价格
	
	boolean flag = false; //产品是否生产完毕的标识，默认情况是没有生产完成。
	
}

//生产者
class Producer extends Thread{
	
	Product  p ;  	//产品
	
	public Producer(Product p) {
		this.p  = p ;
	}
	
	
	
	@Override
	public void run() {
		int i = 0 ; 
		while(true){
		 synchronized (p) {
			if(p.flag==false){
				 if(i%2==0){
					 p.name = "苹果";
					 p.price = 6.5;
				 }else{
					 p.name="香蕉";
					 p.price = 2.0;
				 }
				 System.out.println("生产者生产出了："+ p.name+" 价格是："+ p.price);
				 p.flag = true;
				 i++;
				 p.notifyAll(); //唤醒消费者去消费
			}else{
				//已经生产 完毕，等待消费者先去消费
				try {
					p.wait();   //生产者等待
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			 
		}	
	  }	
	}
}


//消费者
class Customer extends Thread{
	
	Product p; 
	
	public  Customer(Product p) {
		this.p = p;
	}
	
	
	@Override
	public void run() {
		while(true){
			synchronized (p) {	
				if(p.flag==true){  //产品已经生产完毕
					System.out.println("消费者消费了"+p.name+" 价格："+ p.price);
					p.flag = false; 
					p.notifyAll(); // 唤醒生产者去生产
				}else{
					//产品还没有生产,应该 等待生产者先生产。
					try {
						p.wait(); //消费者也等待了...
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}	
	}
}

public class Demo5 {
	
	public static void main(String[] args) {
		Product p = new Product();  //产品
		//创建生产对象
		Producer producer = new Producer(p);
		//创建消费者
		Customer customer = new Customer(p);
		//调用start方法开启线程
		producer.start();
		customer.start();
		
		
	}
	
}

五、一些常用线程方法：

Thread(String name) 初始化线程的名字

getName() 返回线程的名字

setName(String name) 设置线程对象名

sleep() 线程睡眠指定的毫秒数。

getPriority() 返回当前线程对象的优先级默认线程的优先级是5

setPriority(intnewPriority) 设置线程的优先级虽然设置了线程的优先级，但是具体的实现取决于底层的操作系统的实现（最大的优先级是10 ，最小的1 ，默认是5）。

currentThread() 返回CPU正在执行的线程的对象

Thread的join方法。当A线程执行到了B线程Join方法时A就会等待，等B线程都执行完A才会执行，Join可以用来临时加入线程执行。例如：

class JoinThread implements Runnable {
	@Override
	public void run() {
		int i = 0;
		while (i < 300) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + " i:" + i);
			i++;
		}
	}
}
public class Demo10 {
	public static void main(String[] args) throws InterruptedException {
		JoinThread jt = new JoinThread();
		Thread th = new Thread(jt, "one");
		th.start();
		int i = 0;
		while (i < 200) {
			if (i == 100) {
				th.join();
			}
			System.err.println(Thread.currentThread().getName() + " i:" + i);
			i++;

		}
	}
}

关于死锁：http://blog.youkuaiyun.com/weiyongle1996/article/details/71511956

关于进程同步：http://blog.youkuaiyun.com/weiyongle1996/article/details/72790165

关于线程：http://blog.youkuaiyun.com/weiyongle1996/article/details/72785311