稳稳当当学java之并发编程(20)

第二十二章 并发编程

1.作业回顾

以指定的编码读取文件内容,并将读到的内容以指定的编码写文件,两种编码都配置到properties文件中。

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.util.Properties;

public class Day2201 {
	public static void main(String[] args) {
		String readCharset = null;
		String writeCharset = null;
		String readFilePath = null;
		String writeFilePath = null;
		
		InputStream is = Day2201.class.getResourceAsStream("/file.properties");
		Properties props = new Properties();
		
		try {
			props.load(is);
			readCharset = props.getProperty("readFilePath");
			writeCharset = props.getProperty("writeCharset");
			readFilePath = props.getProperty("readFilePath");
			writeFilePath = props.getProperty("writeFilePath");
		
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				is.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
		InputStreamReader isr = null;
		OutputStreamWriter osw = null;
		
		try {
			isr = new InputStreamReader(new FileInputStream(readFilePath), readCharset);
			osw = new OutputStreamWriter(new FileOutputStream(writeFilePath), writeCharset);
			
			char[] chars = new char[256];
			int len = 0;
			
			while(-1 != (len = isr.read(chars))){
				osw.write(chars, 0, len);
			}	
			
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				isr.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				osw.flush();
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				osw.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}	
	}
}

2.进程和线程

​ 在并发编程中,有两个基本的执行单元,进程和线程。

​ 计算机运行时拥有很多活动的进程和线程,即使是单核系统也是如此。

​ 进程可以理解为一个正在运行的软件,进程在运行时有独立的资源和内存空间。进程与进程之间不共享数据。进程的创建开销很大,因为要分配独立的资源和内存空间。

​ 线程,例如音乐播放器在播放声音的同时可以滚动歌词,每个功能都由单独的一个线程来完成。 一个进程由很多线程组成,线程与线程之间共享进程的资源和内存空间。线程的创建开销很小,因为不需要分配独立的资源和内存空间。

​ 计算机在运行时有很多线程,但是同一时刻只能有一个线程能运行。为了保证每个线程都能得到执行,操作系统将cpu的时间分为一个个细小的时间片,并给线程分配执行权。当一个线程获得cpu的执行权后,它可以在时间片内运行,当时间片过后,线程被剥夺执行权,操作系统开始进行下一轮执行权的分配。因为时间片很短,在一秒内每个线程都将得到多次执行机会,因此在用户的角度来看,感觉线程是并行执行的。

​ 执行java程序需要使用java命令,java命令会运行java.exe程序,因此会创建一个进程。当java进程创建后,会创建一个线程来执行main方法的代码,这个线程叫做主线程。我们之前运行的java程序都是单线程的。

3.创建线程

在java中创建线程有两种方式:继承Thread类,实现Runnable接口。

3.1 继承Thread类来创建线程

class Mythread1 extends Thread{
	//重写run方法
	//当线程得到执行权,就会执行run方法中的代码
	//当run方法中的代码执行完毕后,线程就死掉了
	//线程可能run方法没有执行完毕,时间片就结束了
	//线程会记录它执行的哪个代码了,当再次得到时间片,它会接着往下执行
	@Override
	public void run() {
		for (int i = 0; i < 1000; i++) {
//			System.out.println(this.getName() + ":" + (i + 1));
			System.out.println(Thread.currentThread().getName() + ":" + (i + 1) );
		}
	}
}

public class Day2202 {
	public static void main(String[] args) {
		Thread t1 = new Mythread1();//创建一个线程对象t1,并不是真正的在创建线程
		Thread t2 = new Mythread1();//创建一个线程对象t2,并不是真正的在创建线程
		
		//start方法是启动线程,至于这个线程什么时候得到执行权,要看操作系统的调度
		t1.start();//启动线程t1
		t2.start();//启动线程t2
		
		for (int i = 0; i < 1000; i++) {
			//主线程
			//得到当前线程,执行此代码的线程对象
			Thread mainThread = Thread.currentThread();
			//getName方法会返回线程的名字
			System.out.println(mainThread.getName() + ":" + (i + 1));
		}	
	}
}

3.2 实现Runnable接口来创建线程

class MyThread2 implements Runnable{

	@Override
	public void run() {
		for (int i = 0; i < 1000; i++) {
			//输出当前线程的名字
			System.out.println(Thread.currentThread().getName() + ":" + (i + 1) );
		}	
	}	
}

public class Day2203 {
	public static void main(String[] args) {
		Thread t1 = new Thread(new MyThread2());
		
		t1.start();
		
		Thread t2 = new Thread(new MyThread2());
		
		t2.start();
	}
}

4.线程类的方法

4.1 sleep方法

Thread.sleep(long millis)导致当前线程暂停执行指定的时间段。

public class Day2204 {
	public static void main(String[] args) {
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName() + ":" + (i + 1));
			
			try {
				//让当前线程睡眠1000毫秒
				//让出执行权,进行睡眠,睡眠结束后再参与cpu执行权的争夺
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

4.2 join方法

t1.join方法将导致当前线程等待t1执行完毕。

public class Day2205 {
	public static void main(String[] args) {
		Thread t1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				for (int i = 0; i < 200; i++) {
					//输出当前线程的名字
					System.out.println(Thread.currentThread().getName() + ":" + (i + 1) );
				}	
			}
		});
		//修改名称为t1
		t1.setName("t1");
		
		Thread t2 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				for (int i = 0; i < 100; i++) {
					//输出当前线程的名字
					System.out.println(Thread.currentThread().getName() + ":" + (i + 1) );
				}
			}
		});
		//修改名称为t2
		t2.setName("t2");
				
		Thread t3 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				for (int i = 0; i < 100; i++) {
					//输出当前线程的名字
					System.out.println(Thread.currentThread().getName() + ":" + (i + 1) );
				}
			}
		});
		//修改名称为t3
		t3.setName("t3");
		
		//t1和t2和主线程一起争夺时间片
		t1.start();
		t2.start();
		
		try {
			//让当前线程(主线程)暂停执行,等待t2执行结束主线程在恢复执行
			t2.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}		
		
		System.out.println("主线程恢复执行");
		t3.start();
	}
}

4.3 stop方法

t1.stop会导致线程t1立即终止执行。

public class Day2206 {
	public static void main(String[] args) {
		Thread t1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				for (int i = 0; i < 100; i++) {
					System.out.println(Thread.currentThread().getName() + ":" + (i + 1) );
				}
				
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}	
			}
		});
		
		t1.start();
		
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		//终止t1的执行
		t1.stop();
		//t1至少需要1000毫秒才可以执行完毕
		//主线程睡100毫秒后t1还没执行完毕
	}
}

4.4 interrupt方法

t1.interrupt会将设置t1线程为中断状态,但不会导致t1线程立即终止执行。 被中断的线程可以选择继续执行,也可以选择停止执行。

public class Day2207 {
	public static void main(String[] args) {
		Thread t1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				for (int i = 0; i < 1000; i++) {
					//检查当前线程是否被打断
					//isInterrupted方法返回中断状态
					if (Thread.currentThread().isInterrupted()) {
						System.out.println("线程被打断了");
						break;					
					}else {
						System.out.println(Thread.currentThread().getName() + ":" + (i + 1) );
					}					
				}				
			}
		});
		
		t1.start();
		
		try {
			//让主线程先睡10毫秒
			Thread.sleep(10);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		//打断线程t1,设置t1的中断状态为true
		t1.interrupt();
	}
}

4.5 守护线程

java中的线程分为两种:守护线程和非守护线程。

守护线程是一种特殊的线程,当java虚拟机中所有的非守护线程都执行完毕后,守护线程就会终止执行。java中的垃圾回收器GC就是守护线程的典型例子。

平常使用的都是非守护线程。

public class Day2208 {
	public static void main(String[] args) {
		Thread t1 = new Thread(new Runnable() {

			@Override
			public void run() {
				for (int i = 0; i < 100; i++) {
					System.out.println(Thread.currentThread().getName() + ":" + (i + 1));
					
				}
			}
		}, "t1");
		
		Thread t2 = new Thread(new Runnable() {

			@Override
			public void run() {
				while(true) {
					System.out.println("守护线程在运行");
				}
			}
		}, "t2");
		
		//设置t2为守护线程
		t2.setDaemon(true);
		
		t1.start();//非守护线程执行完
		t2.start();//守护线程就会终止执行
	}
}

5.多线程并发问题

5.1原因

线程是并行执行的,当两个线程同时修改同一个数据,就会产生线程并发问题。

public class Account {
	private int money = 0;
	
	public void increase() {
		money = money + 1;
	}
	
	public void decrease() {
		money = money - 1;
	}

	@Override
	public String toString() {
		return "Account [money=" + money + "]";
	}
}
public class IncreaseThread extends Thread{
		private Account account;

		public IncreaseThread(Account account) {
			super();
			this.account = account;
		}
		
		public void run() {
			for (int i = 0; i < 10000; i++) {
				account.increase();
			}
		}
}
public class DecreaseThread extends Thread{
		private Account account;

		public DecreaseThread(Account account) {
			super();
			this.account = account;
		}
		
		public void run() {
			for (int i = 0; i < 10000; i++) {
				account.decrease();
			}
		}
}
public class Day2209 {
	public static void main(String[] args) {
		Account account = new Account();
		
		Thread t1 = new IncreaseThread(account);
		
		Thread t2 = new DecreaseThread(account);
		
		t1.start();
		
		t2.start();
		
		//主线程等待t1和t2执行结束
		try {
			t1.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		try {
			t2.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		System.out.println(account);//有正有负
	}
}

在这里插入图片描述

5.2 synchronized同步代码块

使用同步代码块,来保证增加1和减少1的操作都是原子的。

public class IncreaseThread extends Thread{
		private Account account;

		public IncreaseThread(Account account) {
			super();
			this.account = account;
		}
		
		public void run() {
			for (int i = 0; i < 10000; i++) {
				
				//synchronized是同步代码块
				//要执行同步代码块,必须先获取account对象的锁
				//每个对象都有一把锁
				//同步锁同一时刻只能被一个线程获取
				//没有获得锁的线程就会等待别的线程释放锁
				//当线程在执行同步代码块时,时间片结束,线程会暂停执行,但是不会释放锁
				//如果一个线程期望得到锁但是没有得到,那么它会放弃时间片
				synchronized (account) {
					account.increase();
				}
				
			}
		}
}
public class DecreaseThread extends Thread{
		private Account account;

		public DecreaseThread(Account account) {
			super();
			this.account = account;
		}
		
		public void run() {
			for (int i = 0; i < 10000; i++) {
				
				synchronized (account) {
					account.decrease();
				}
				
			}
		}
}

6.练习

1,继承Thread类创建一个线程t1,实现Runnable接口创建一个线程t2。t1中使用for循环输出1000次自己的名字,每次输出后睡眠10毫秒,t2中使用for循环输出1000次自己的名字,每次输出后睡眠20毫秒。让主线程等待t1和t2都执行结束,主线程才恢复执行。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

十年之伴

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值