java多线程探索一

拼搏现实的明天。 2022-04-23 05:50 135阅读 0赞

现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程的内存。“同时”执行是人的感觉，在线程之间实际上轮换执行。

一、java中传统方式创建线程

1、继承Thread重写run方法

public class MyThread extends Thread{
            @Override
            public void run() {
                super.run();
                System.out.println("我是线程--->"+Thread.currentThread().getName());
            }
        }
    
       @Test
        public void   test(){
            MyThread  myThread=new MyThread();
            MyThread  myThread1=new MyThread();
            myThread.start();
            myThread1.start();
        }

执行结果：

我是线程--->Thread-1  
我是线程--->Thread-0

2、实现runnable接口

public class MyRunnable implements Runnable {
            @Override
            public void run() {
                System.out.println("我是线程--->" + Thread.currentThread().getName());
            }
        }
    
    
        @Test
        public void test1() {
            MyRunnable myRunnable = new MyRunnable();
            Thread  thread=new Thread(myRunnable);
            Thread  thread1=new Thread(myRunnable);
            thread.start();
            thread1.start();
        }

执行结果：

我是线程--->Thread-1  
我是线程--->Thread-0

3、Callable 、Future创建带返回值的线程

public static void main(String[] args) {
    		ExecutorService executorService = Executors.newSingleThreadExecutor();
    		Future<String> future = executorService.submit(new Callable<String>() {
    			@Override
    			public String call() throws Exception {
    				return "通过Callable方式创建线程的返回结果";
    			}
    		});
    
    		try {
    			String res = future.get();
    			System.out.println(res);
    		} catch (InterruptedException | ExecutionException e) {
    			e.printStackTrace();
    		}
    
    	}

二、多线程

1、多线程互斥技术，使用 synchronized关键字处理线程安全问题

以经典的银行取款为例

public class Account {
    	
    	private SimpleDateFormat  sdf=new SimpleDateFormat("YYYY-MM-DD HH:mm:ss");
    	
    	///账户余额
    	private  int  account=1000;
    	
    	public  void  take(int  m) {
    		account-=m;
    		System.out.println(getTime()+"********取款："+m+"元");
    	}
    	
    	public  void   save(int  m) {
    		account+=m;
    		System.out.println(getTime()+"--------存款："+m+"元");
    	}
    	
    	public  void getAccount() {
    		System.out.println(getTime()+"########余额："+account+"元");
    	}
    
    	
    	String   getTime() {
    		return  sdf.format(new Date());
    	}
    }

模拟多线程：

public static void main(String[] args) {
    
    		account = new Account();
    			
    			for (int i = 0; i < 3; i++) {
    				new Thread(new Runnable() {
    					@Override
    					public void run() {
    						try {
    							Thread.sleep(1000);
    						} catch (InterruptedException e) {
    							e.printStackTrace();
    						}
    						account.take(100);
    					}
    				}).start();
    
    				new Thread(new Runnable() {
    					@Override
    					public void run() {
    						try {
    							Thread.sleep(1000);
    						} catch (InterruptedException e) {
    							e.printStackTrace();
    						}
    						account.save(100);
    						account.getAccount();
    					}
    				}).start();
    			
    		}
    	}

看看执行结果，余额度尽然变成900了

2019-01-25 17:13:08\*\*\*\*\*\*\*\*取款：100元  
2019-01-25 17:13:08\*\*\*\*\*\*\*\*取款：100元  
2019-01-25 17:13:08--------存款：100元  
2019-01-25 17:13:08\#\#\#\#\#\#\#\#余额：900元  
2019-01-25 17:13:08--------存款：100元  
2019-01-25 17:13:08\#\#\#\#\#\#\#\#余额：900元  
2019-01-25 17:13:08\*\*\*\*\*\*\*\*取款：100元  
2019-01-25 17:13:08--------存款：100元  
2019-01-25 17:13:08\#\#\#\#\#\#\#\#余额：900元

为了解决多线程下共享数据脏读问题，java提供了线程锁

2、线程锁

（1）锁的分类：  自旋锁、阻塞锁、可重入锁、读写锁、互斥锁、悲观锁、乐观锁、公平锁、偏向锁   对象锁、线程锁、锁粗化、锁消除、轻量级锁、重量级锁、独享锁、分段锁

（2）javax常见的锁有：Synchronized  Lock  ReentrantLock  ReentrantReadWriteLocK

Synchronized，它就是一个：非公平，悲观，独享，互斥，可重入的重量级锁

ReentrantLock，它是一个：默认非公平但可实现公平的，悲观，独享，互斥，可重入，重量级锁。       ReentrantReadWriteLocK，它是一个，默认非公平但可实现公平的，悲观，写独享，读共享，读写，可重入，重量级锁。

3、使用Synchronized处理脏读问题

private static Account account;
    
    	public static void main(String[] args) {
    
    		account = new Account();
    
    		for (int i = 0; i < 3; i++) {
    			new Thread(new Runnable() {
    				@Override
    				public void run() {
    					synchronized (account) {
    						try {
    							Thread.sleep(1000);
    						} catch (InterruptedException e) {
    							e.printStackTrace();
    						}
    						account.take(100);
    						account.getAccount();
    					}
    				}
    			}).start();
    
    			new Thread(new Runnable() {
    				@Override
    				public void run() {
    					synchronized (account) {
    						try {
    							Thread.sleep(1000);
    						} catch (InterruptedException e) {
    							e.printStackTrace();
    						}
    						account.save(100);
    						account.getAccount();
    					}
    				}
    			}).start();
    		}
    
    	}

打印结果

2019-01-25 17:30:43\*\*\*\*\*\*\*\*取款：100元  
2019-01-25 17:30:43\#\#\#\#\#\#\#\#余额：900元  
2019-01-25 17:30:44\*\*\*\*\*\*\*\*取款：100元  
2019-01-25 17:30:44\#\#\#\#\#\#\#\#余额：800元  
2019-01-25 17:30:45--------存款：100元  
2019-01-25 17:30:45\#\#\#\#\#\#\#\#余额：900元  
2019-01-25 17:30:46--------存款：100元  
2019-01-25 17:30:46\#\#\#\#\#\#\#\#余额：1000元  
2019-01-25 17:30:47\*\*\*\*\*\*\*\*取款：100元  
2019-01-25 17:30:47\#\#\#\#\#\#\#\#余额：900元  
2019-01-25 17:30:48--------存款：100元  
2019-01-25 17:30:48\#\#\#\#\#\#\#\#余额：1000元

四、wait和notify实现线程间的通信

现一个需求，子线程循环20次，主线程循环10次，子线程执行2次，主线程执行1次，按顺序交替执行

public class ThreadTest {
    
    	public static void main(String[] args) {
    
    		ThreadSubMain threadSubMain = new ThreadSubMain();
    
    		new Thread(new Runnable() {
    			@Override
    			public void run() {
    				for (int i = 0; i < 10; i++) {
    					threadSubMain.subExcute(i);
    				}
    			}
    		}).start();
    
    		threadSubMain.mainExcute();
    	}
    
    	static class ThreadSubMain {
    
    		private boolean isWait = true;
    
    		/// 子线程循环20次
    		synchronized void subExcute(int i) {
    			while (!isWait) {
    				try {
    					this.wait();
    				} catch (Exception e) {
    					e.printStackTrace();
    				}
    			}
    			
    			for (int j = 0; j < 2; j++) {
    				System.out.println("第" + i + "个，第" + j + "次子线程--->" + Thread.currentThread().getName());
    			}
    			//当子线程执行两次后，改变标识符，唤醒主线程执行；
    			isWait = false;
    			this.notify();
    		}
    
    		/// 主线程循环10次
    		synchronized void mainExcute() {
    			for (int i = 0; i < 10; i++) {
    				while (isWait) {
    					try {
    						this.wait();
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    					System.out.println("第" + i + "个主线程--->" + Thread.currentThread().getName());
    				}
    				//当主线程执行一次后，改变标识符，唤醒主子线程
    				isWait = true;
    				this.notify();
    			}
    		}
    	}
    
    }

第0个，第0次子线程--->Thread-0  
第0个，第1次子线程--->Thread-0  
第0个主线程--->main  
第1个，第0次子线程--->Thread-0  
第1个，第1次子线程--->Thread-0  
第1个主线程--->main  
第2个，第0次子线程--->Thread-0  
第2个，第1次子线程--->Thread-0  
第2个主线程--->main  
第3个，第0次子线程--->Thread-0  
第3个，第1次子线程--->Thread-0  
第3个主线程--->main  
第4个，第0次子线程--->Thread-0  
第4个，第1次子线程--->Thread-0  
第4个主线程--->main  
第5个，第0次子线程--->Thread-0  
第5个，第1次子线程--->Thread-0  
第5个主线程--->main  
第6个，第0次子线程--->Thread-0  
第6个，第1次子线程--->Thread-0  
第6个主线程--->main  
第7个，第0次子线程--->Thread-0  
第7个，第1次子线程--->Thread-0  
第7个主线程--->main  
第8个，第0次子线程--->Thread-0  
第8个，第1次子线程--->Thread-0  
第8个主线程--->main  
第9个，第0次子线程--->Thread-0  
第9个，第1次子线程--->Thread-0  
第9个主线程--->main