java 多线程详解

电玩女神 2022-08-06 08:16 195阅读 0赞

### 关于线程的概念 ###

1、程序一般是指一段静态代码，静态对象;进程是程序的一次执行过程或正在运行的程序动态的的过程，有它的产生、存在和消亡的过程;线程是指一个程序内部的一条执行路径，也就是说每一个任务就代表一个线程。进程与线程相互联系然而又有区别，从本质上来说每个进程都有自己的一整套变量，而线程间可以共享变量，共享变量使得线程之间的通信比进行之间通信更有效、更容易。

2、并不是每种情况都需要多线程，当程序需要同时执行两个或多个任务;当程序需要实现一些等待任务，如用户的输入，文件读写，网络操作，搜索;当程序需要运行一些后台程序。在这些情况下我们需要使用多线程。

3、线程的生命周期：每个线程都有新建、就绪、运行、阻塞、死亡这五种状态

![Center][]

### 创建线程的两种方式 ###

1、继承Thread类：

a.创建一个类继承Thread;b.重写run()方法，将要执行的业务逻辑代码放在run()方法体中;c.在主类中创建子线程类的实例;d.调用线程方法start(),将此线程变为就绪状态。

package com.thread;
    public class TestThread {
    	public static void main(String [] args){
    	       //3、创建一个子类对象
    		SubThread st=new SubThread();
    		//4、调用线程的start（）方法，开始启动线程;调用相应的run()方法
    		st.start();
    		//这个是主线程的方法 
    		for(int i=1;i<=100;i++){
    			System.out.println(Thread.currentThread().getName()+":"+i);
    			
    		}
    	}
    }
    //1、创建一个继承Thread的子类
    class SubThread extends Thread{
    	//2、重写run()方法
    	@Override
    	public void run() {
                for(int i=1;i<=100;i=i+2）{
    		 System.out.println(Thread.currentThread().getName()+":"+i);
    	    }
    	}
    }

2、实现Runnable接口

a.创建一个类实现Runnable接口;b.重写run()方法，将业务逻辑代码放入在run()方法中;c.创建一个Runbable接口实现类的对象的实例 d.将这个对象作为形参传递给Thread类的构造器中，创建Thread类对象，然后再启动线程start()方法。

package com.thread;
    public class ThreadTest {
        public static void main(String[] args) throws Exception{
        	MyRunnable r=new MyRunnable();//c.创建一个Runbable接口实现类的对象的实例 
        	Thread t=new Thread(r);//d.将这个对象作为形参传递给Thread类的构造器中，创建Thread类对象，然后再启动线程start()方法。
        	t.setName("自定义线程：");
        	t.start();
        	System.out.println(Thread.currentThread().getName());
    	}
    }
    class MyRunnable implements Runnable{//a.创建一个类实现Runnable接口
    	@Override
    	public void run() {//b.重写run()方法，将业务逻辑代码放入在run()方法中
               for(int i=0;i<10;i++){
            	   
        	   System.out.println(Thread.currentThread().getName()+i);
           }
    	}
    }

3、这两种方式创建线程的异同在于a.Thread类其实也是实现Runnable接口;b.实现Runnable接口的方式要优于继承Thread类，首先实现的方式避免java中单继承的缺点，其次如果多个线程操作同一份数据资源，更加适合用实现的方式

### 线程中Thread类常用的方法 ###

1、start():启动线程并执行相应的run方法

2、Thread.currentThread()   Thread.currentThread().getName()、Thread.currentThread().setName("设置的name")           获取当前线程/获取当前线程的名字/设置当前线程的名字

3、sleep(long time):显式的让线程休眠，其中time以毫秒为单位

4、yield():让调用这个方法的线程释放当前cpu的执行权利

5、线程通信的方法:wait():另当前线程挂起并放弃cpu、同步资源使别的线程可以访问并修改共享资源，而当前线程排队等待再一前次对资源的访问;

notify():唤醒正在排队等待同步资源的线程中优先级别最高者结束等待;

notifyAll()：唤醒所有正在排队等待资源的线程结束等待。

6、join()：在A线程中调用B线程的Join()方法，表示强制执行B线程，这个时候A线程停止执行，直到B执行完毕A才可以继续执行。

### 线程的安全问题 ###

一、线程安全问题的原因：由于一个线程正在操作共享数据，未执行完毕的情况下，另外一个线程参与进来，导致共享数据在安全上出了问题。如银行的转账存款业务，卖票业务等等。

二、解决线程安全的办法

1、同步块synchronized：将需要同步的业务逻辑代码放在synchronized(this)\{ ...\}这个同步块中

package com.thread;
    public class Demo {
    	public static void main(String[] args) {
    		sell_Window sell=new sell_Window();
    		Thread t1=new Thread(sell);//开启三个窗口同时卖票
    		Thread t2=new Thread(sell);
    		Thread t3=new Thread(sell);
    		t1.start();
    		t2.start();
    		t3.start();
    	}
    }
    class sell_Window implements Runnable{//实现Runnable接口，把买票的业务逻辑放在run()方法中
        int num=100; 
        @Override
        public void run(){
          while(true){
    	 synchronized(this) {//利用同步块来实现线程安全，this表示当前类，我们也可以使用一个对象来做锁对象，其中利用</span><span style="font-size:12px;">Demo.class字节码也是比较好的 
    	    if(num>0){
                       try{
    			Thread.sleep(100);
         	                System.out.println("窗口 "+Thread.currentThread().getName()+"：售第"+(num--)+"张票");
    		      }catch (Exception e) {
    			e.printStackTrace();
    		      }  
    	    }else{
    		 break;
    	    }
            }
         } 
      }
    }

2、同步方法 synchronized：将需要同步的方法加上关键字：synchronized如publicsynchronized void set(String name)\{...\}

package com.thread;
    public class Demo {
    	public static void main(String[] args) {
    		sell_Window sell=new sell_Window(new SellTicket());
    		Thread t1=new Thread(sell);//开启三个窗口同时卖票
    		Thread t2=new Thread(sell);
    		Thread t3=new Thread(sell);
    		t1.start();
    		t2.start();
    		t3.start();
    	}
    }
    class SellTicket{//共享数据区，以及买票的方法
    	int num=100;
    	public synchronized void sell(){//同步方法
    		if(num>0){
    			System.out.println("窗口 "+Thread.currentThread().getName()+"：售第"+(num--)+"张票");
    		}else{
    			Thread.currentThread().stop();
    		}
    		
    	}
    }
    class sell_Window implements Runnable{//实现Runnable接口，把买票的业务逻辑放在run()方法中
    	SellTicket sellTicket;
    	public sell_Window(SellTicket sellTicket) {
    		this.sellTicket=sellTicket;
    	}
    	@Override
    	public void run(){
    		  while(true){
    			  try{
    				  Thread.sleep(100);
    				  sellTicket.sell();
    			  }catch (Exception e) {
    				e.printStackTrace();
    			}
    			 
    		  }
    	}
    }

3、锁Lock，在线程同步中的Lock其实功能上和synchronized有着异曲同工的效果，不过Lock可以提供更加细度的控制，在java中使用Lock锁的方式如下：

package com.thread;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    /*线程同步中的锁Lock */
    public class ThreadLock {
    	public static void main(String[] args) {
    	     new ThreadLock().init();
    	}
    	public void init(){
    	   final Outputer outputer=new Outputer();
    	   new Thread(new Runnable() {//匿名线程
             	@Override
    		public void run() {//run()方法
    		     while(true){
       			try {
    			       Thread.sleep(10);
                                  outputer.output("zhangxiaoxiang");//执行的任务
                    } catch (InterruptedException e) { 
                                e.printStackTrace(); 
                            }
                   }
                 }
              }).start();
                new Thread(new Runnable() {
                      @Override
                     public void run() {
                          while(true){
                               try {
                                      Thread.sleep(10);
                                            outputer.output("admin");
                                    } catch (InterruptedException e) {
                                           e.printStackTrace();
                                   }
                           }
                     }
               }).start();
            }
       static class Outputer{
              Lock lock=new ReentrantLock();//获取锁
              public void output(String name) {
                  int len=name.length();
                  lock.lock();//加锁
                  try{
                      for(int i=0;i<len;i++){
                        System.out.print(name.charAt(i));
                      }
                      System.out.println();
                  }catch(Exception e){
                      e.printStackTrace();
                  }finally{   
                      lock.unlock();//释放锁
                  }
                }
           }
       }

在Lock中存在比较有用的两种锁，读写锁(ReadWriteLock)，使用这样的锁可以保证读文件的时候可以并发，读写和写文件不可以并发。下面用一个比较实用的例子来说明读写锁的优点。  
设计一个简易的cache系统：

package com.thread;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.locks.ReadWriteLock;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    /*设置缓存系统:
     * 多个人进行读取数据时，可以并行，所以这时候只需要读锁;当有人发现没有数据时，这时候需释放掉
     * 读锁加上一个写锁，在写的时候不能被读取，写完之后就还原成读锁让其它人可以读取
     *  */
    public class Thread_CacheDemo {
    	private Map<String,Object> cache=new HashMap<String,Object>();
    	public static void main(String[] args) {
    	}
    	//得到数据
    	private ReadWriteLock rwl=new ReentrantReadWriteLock();
    	public Object getData(String key){//多线程读取时
    		rwl.readLock().lock();//读锁
    		Object value=null;
    		try{
    			value=cache.get(key);
    			if(value == null){
    				rwl.readLock().unlock();//释放读锁
    				rwl.writeLock().lock();//写锁
    				try {
    				    if(value == null){
    				    	value="aaaa";//这里实际上是查询数据库
    				    }
    				} catch (Exception e) {
    					
    				}finally{
    					rwl.writeLock().unlock();//释放写锁
    					rwl.readLock().lock();//加上读锁
    				}
    			}
    		}catch (Exception e) {
    			e.printStackTrace();
    		}finally{
    			rwl.readLock().unlock();//释放读锁
    		}
    	    return value;
    	}
    }

### 线程间通信 ###

1、线程通信的概念：线程通信是指线程间相互交流的过程，一个线程可以释放自己的cpu权利来给其它被唤醒的线程使用。

2、线程通信的方法，线程通信主要用到了wait(),notif(),notifyAll(),线程通信的一个经典案例就是生产者和消费者调度算法。下面是生产者和消费者调度算法的实现过程：

package com.thread;
    /*生产者与消费者的问题
     *     生产者（Productor）将产品交给店员（Clerk),而消费者（Customer）从店员处取走产品
     *   ，店员一次只能持有固定数量的产品（比如20），如果生产者试图生 产更多的产品，店员会叫生产者停一下，
     *   如果店中有空位放产品了再通知生产者继续生产;如果店中没产品了，店员会告诉消费者等一下，如果店中有了产品再
     *   通知消费者。
     *    1、多线程：生产者，消费者
     *    2、共享数据（资源）：产品的数量 
     *    3、需要线程安全
     *    4、需要线程通信：生产者与消费者通信
     * */
    public class Produce_consume {
    	public static void main(String[] args) {
    	Clerk clerk=new Clerk();//共享数据
    	Producer p=new Producer(clerk);//生产者
    	Consumer c=new Consumer(clerk);//消费者
    	Thread t1=new Thread(p);//生产者线程
    	Thread t3=new Thread(p);//生产者线程
    	Thread t2=new Thread(c);//消费者线程
    	t1.setName("生产者1");
    	t2.setName("消费者");
    	t3.setName("生产者2");
    	t1.start();
    	t2.start();
    	t3.start();
    	}
    }
    //生产者
    class Producer implements Runnable{
    	Clerk clerk;
    	public Producer(Clerk clerk) {
    		this.clerk=clerk;
    	}
    	@Override
    	public void run() {
    		System.out.println("生产者开始生产产品");
    		while(true){
    		  try{
    			Thread.currentThread().sleep(10);
                           clerk.addProduct();//生产者生产产品
                      } catch (InterruptedException e) {
                           e.printStackTrace(); 
                      }
                   }
                 }
               }
    
    //消费者
    class Consumer implements Runnable{
        Clerk clerk;
        public Consumer(Clerk clerk){
             this.clerk=clerk;
        }
        @Override
        public void run(){
            System.out.println("消费者消费产品"); 
            while(true){ 
                try {  
                       Thread.currentThread().sleep(10);
                       clerk.consumeProduct(); //消费者消费产品
                } catch(InterruptedException e) {
                       e.printStackTrace();
                } 
            }
       }
    }
    //店员,这是一个共享的数据，供生产者和消费者使用
    class Clerk{
        int product;
        public synchronized void addProduct(){
                 //生产产品
                if(product>=20){
                  try{
                   //产品数大于或等于20，暂停生产
                   wait();//释放cpu资源
                   } catch (InterruptedException e){
                    e.printStackTrace();
                  }
                }else{
                    product++;
                    System.out.println(Thread.currentThread().getName()+":生产了第"+product+"个产品");
                    notifyAll();//一旦有产品生产，去唤醒消费者进行消费，notifyAll()唤醒其它线程
                }
               }
       public synchronized void consumeProduct(){
        //消费产品
         if(product<=0){ 
               try {
                   wait();//产品数少于或等于0，停止消费
                } catch (InterruptedException e) { 
                   e.printStackTrace();
               }
        }else{
           System.out.println(Thread.currentThread().getName()+":消费了第"+product+"个产品");
           product--;
           notifyAll();//有消费，就去唤醒生产者进行生产
        }
       }
    }

### 线程范围的共享数据ThreadLocal类 ###

1、ThreadLocal类表示可以存放当前线程的变量，同时这个变量可以让这个线程中的所有对象共享。这个类的底层实现方式和HashMap()大致相同，它分别有get(),set(),remove(),setInitialValue()四个方法，这四个方法分别表示得到当前线程相关的变量、设置当前线程的相关变量、把与当前线程有关的变量全部remve、设置初始化的值。当我们遇到需要在一个线程中放置多个变量的情况时，可以把这些变量封装成一个对象来存储。

package com.thread;
    import java.util.Random;
    public class ThreadLocal_fun {
    	   private static ThreadLocal<Integer> x=new ThreadLocal<Integer>();//表示放置一个变量
    	   private static ThreadLocal<MyThreadScopeDate> xObj=new ThreadLocal<MyThreadScopeDate>();//放置一个变量对象
    	   public static void main(String[] args) {
    		  for(int i=0;i<2;i++){//开启两个线程
    			 new Thread(new Runnable() {
    			    @Override
    			    public void run() {
    		                int data=new Random().nextInt();
    		                System.out.println(Thread.currentThread().getName()+" has put data:"+data);
    		                x.set(data);
    		                MyThreadScopeDate.getThreadInstance().setName("admin");//为每个线程放置变量
    		                MyThreadScopeDate.getThreadInstance().setAge(data);
    		                new A().get();
    			        new B().get();
    			     }
    			   }).start();
    			}
    	      }		
    		static class A{
    			public void get(){
    				 int data=x.get();
    				 System.out.println("A:"+Thread.currentThread().getName()+" has put data:"+data);
    				 MyThreadScopeDate obj=MyThreadScopeDate.getThreadInstance();
    				 System.out.println("A"+Thread.currentThread().getName()+":"+obj);
    			}
    		}
    		static class B{
    			public void get(){
    				 int data=x.get();
    				 System.out.println("B:"+Thread.currentThread().getName()+" has put data:"+data);
    				 MyThreadScopeDate obj=MyThreadScopeDate.getThreadInstance();
    				 System.out.println("A:"+Thread.currentThread().getName()+":"+obj);
    			}
    		}
    	}
    //封装的变量对象 ,单例
    class MyThreadScopeDate{
    	private MyThreadScopeDate(){}//私有化的构造函数不允许实例化
    	private static ThreadLocal<MyThreadScopeDate> map=new ThreadLocal<MyThreadScopeDate>();
    	public static  MyThreadScopeDate getThreadInstance(){
    		MyThreadScopeDate instance=map.get();
    		if(instance == null){
    			instance=new MyThreadScopeDate();
    			map.set(instance);
    		}
    		return instance;
    	}
    	private String name;
    	private  int age;
    	
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	@Override
    	public String toString() {
    		return "MyThreadScopeDate [name=" + name + ", age=" + age + "]";
    	}
    }

### 线程池 ###

多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力;一般来说可以创建三种不同类型的线程池，同时线程池也为我们提供了关闭的方法：

a.创建固定大小 的线程池：一次只能执行三个任务，其他任务等待。 Executors.newFixedThreadPool(3)

b.创建缓存线程池：线程数动态量化，空闲线程自动回收。  Executors.newCachedThreadPool()

c.创建单一线程池：池中只有一个线程，如果线程意外终止就新产生一个。Executors.newSingleThreadExecutor()

d.shutdown();//当所有的任务都运行完后，就关闭线程池

e.shutdownNow();//立刻关闭线程池

package com.thread;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    public class ThreadPool {
    	public static void main(String[] args) {
               //ExecutorService threadPool=Executors.newFixedThreadPool(3);//创建固定大小的线程池，这里表明只能同时运行3个线程。
    	   //ExecutorService threadPool=Executors.newCachedThreadPool();//创建缓存线程池,为所有的任务都分配一个线程,自动关闭空闲的线程
    	     ExecutorService threadPool=Executors.newSingleThreadExecutor();//创建单一线程池。
    	     for(int i=1;i<10;i++){//循环往线程池中放10个任务
        	        final int task=i;
        	        threadPool.execute(new Runnable() {//在线程池中放任务
        			@Override
        			public void run() {
        				for(int j=5;j<10;j++){
        					 try {
    							Thread.sleep(20);
    						} catch (InterruptedException e) {
    							e.printStackTrace();
    						}
        					 System.out.println("线程"+Thread.currentThread().getName()+" loop of"+j+"次,在执行第 "+task+"个任务！");
        				}		
        			}
        		});  
           }
       				 System.out.println("提交了10个任务");
       				//threadPool.shutdown();//当所有的任务都运行完后，就关闭线程池
       			        //threadPool.shutdownNow();//立刻关闭线程池
    	}
    }

[Center]: /images/20220806/da075f2e7cdc416bbf530170687add70.png