JAVA多线程并发

深藏阁楼爱情的钟 2021-06-11 15:12 708阅读 0赞

# 前言 #

老王和他媳妇儿一起做饭，中午老王要用刀切肉，切完肉要炖肉，他媳妇儿要用刀切菜，切完菜要炒菜，但是，他俩互不相让，结果到现在午饭都还没吃。

# 进程和线程 #

进程：程序的执行过程，持有资源（共享内存，共享文件）和线程。线程是载体，呈动态性。

线程：线程是系统中最小的执行单元，同一个进程中有多个线程，线程共享进程的资源。线程的交互方式有两种：互斥 同步。

# 解读前言 #

老王和他媳妇儿一起做饭----做饭就是一个进程

老王用刀切肉----这是一个线程

老王炖肉----这是一个线程

老王媳妇儿用刀切菜----这是一个线程

老王媳妇儿炒菜----这是一个线程

老王和他媳妇儿抢菜刀，都不给，这就是互斥

老王去炖肉和他媳妇儿去炒菜，两者互不干预，这就是同步

在这整个做午饭的过程中没有谁是静止不懂得，所以这就是进程，持有资源和线程，并且具有动态性。

# 并发 #

定义两个线程，然后这两个线程里面都访问同一个静态变量num，但是此时线程的访问会出现问题，访问的顺序出现差错，运行的结果会提示两个线程访问的全都是同一个变量，都访问了num，然后执行了num++操作，然后才将num打印出来，导致了错误的出现，所以，为了避免这种情况的发生，我们要在线程上加锁，来保证线程访问的正确性。

public class TestSync implements Runnable {
    	Timer timer=new Timer();
    	public static void main(String args[]){
    		TestSync testSync=new TestSync();
    		Thread t1=new Thread(testSync);
    		Thread t2=new Thread(testSync);
    		t1.setName("t1");
    		t2.setName("t2");
    		t1.start();
    		t2.start();
    	}
    	@Override
    	public void run() {
    		timer.add(Thread.currentThread().getName());
    	}
    
    }
    
    class Timer{
    	private static int num = 0;
    	//synchronized:锁定当前对象
    	public void add(String name){
    		num++;
    		try {
    			Thread.sleep(1);
    		} catch (InterruptedException e) {}
    		System.out.println(name+",你是第"+num+"个使用timer的线程");
    		
    	}
    }

![70][]

# 锁 #

将Timer里面的方法添加一个关键字synchroized

class Timer{
    	private static int num = 0;
    	//synchronized:锁定当前对象
    	public synchronized void add(String name){//此行加了关键字
    		num++;
    		try {
    			Thread.sleep(1);
    		} catch (InterruptedException e) {}
    		System.out.println(name+",你是第"+num+"个使用timer的线程");
    		
    	}
    }

这样的目的就是，在t1线程访问时，会将资源锁住，t2要访问的话，就要等待t1释放锁之后才可以访问。所以在t2访问的时候，t1就已经将num++执行完毕，此时，t2才可以进行访问，就会达到我们想要的结果。

![70 1][]

# 死锁 #

public class Demo{
    	public static void main(String args[]){
    		TestDeadLock td1=new TestDeadLock();
    		TestDeadLock td2=new TestDeadLock();
    		td1.flag=1;
    		td2.flag=0;
    		Thread t1=new Thread(td1);
    		Thread t2=new Thread(td2);
    		t1.start();
    		t2.start();
    	}
    }
    
    class TestDeadLock implements Runnable{
    
    	public int flag=1;
    	static Object o1=new Object(), o2=new Object();
    	
    	
    	public void run() {
    		System.out.println("flag="+flag);
    		if(flag == 1){
    			synchronized (o1) {
    				try{
    					Thread.sleep(500);
    				}catch (Exception e) {
    					e.printStackTrace();
    				}
    				synchronized (o2) {
    					System.out.println("1");
    				}
    			}
    		}
    		if(flag == 0){
    			synchronized (o2) {
    				try{
    					Thread.sleep(500);
    				}catch (Exception e) {
    					e.printStackTrace();
    				}
    				synchronized (o1) {
    					System.out.println("0");
    				}
    			}
    		}
    	}	
    }

定义flag作为标识，定义两个线程运行，然后t1和t2互相拿住资源不放，t1和t2还会向对方索取资源，这样就会形成死锁。这段程序的运行结果，互相打印完0和1之后，程序就会陷入死锁，但是此时，程序依旧运行，只不过是没有响应。

![70 2][]

[70]: /images/20210529/8984cd3249af487496b00a4238a37244.png
[70 1]: /images/20210529/c30249a0d85b4b85a242715ef8538ced.png
[70 2]: /images/20210529/767cd48cc5a84dbe93ba04dbc3a6a1d7.png