【13】线程 并发与并行 线程和进程 创建多线程的方式二种 获取线程的名称2种方式 解决线程安全的三种方式

线程

并发与并行

并发：CUP一会执行这个，一会执行那个

并行：CUP同时执行程序

 

进程和线程

进程：在内存中运行的程序

线程：线程是进程的一部分

线程的调度

一个是分时调度 ：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

 

抢占式调度：优先让优先级高的线程使用 CPU ，如果线程的优先级相同，那么会随机选择一个 ( 线程随机性 ) ， Java 使用的为抢占式调用

 

主线程

主线程：执行主（main）方法的线程

单线程程序：java程序中只有一个线程，执行从main方法开始，从上到下依次执行

 创建多线程的方式一

/*
 * 创建多线程程序的第一种方式：创建Thread子类
 * java.lang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须继承Thread类
 * 
 *实现步骤：
 *	1.创建一个Thread类的子类 
 *	2.在Thread类的子类中重写Thread类中的Run方法，设置多线程任务（开启线程要做什么？）
 *	3.创建Thread类的子类对象
 *	4.调用Thread类中的方法start方法，开启新的线程，执行run方法
 *		void start() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
 *		结果是两个线程并发地运行；当前线程（main线程）和另一个线程（创建的新线程,执行其 run 方法）。
 *		 多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。
 *java程序属于抢占式调度,那个线程的优先级高,那个线程优先执行;同一个优先级,随机选择一个执行
 * */
public class Test1 {
	public static void main(String[] args) {
		MyThread m = new MyThread();
		//4.调用Thread类中的方法start方法,开启新的线程,执行run方法
		m.start();//这个就会在栈内存中开辟一个空间，将run方法存放进去
		
		for(int i=1;i<20;i++){
			System.out.println("main"+i);
		}
	}
}

public class MyThread extends Thread {
	
	public void run(){
		for(int i=1;i<20;i++){
			System.out.println("run"+i);
		}
	}

}

获取线程的名称

/*
 * 获取线程的名称：
 * 		1.使用Thread类中的方法getName()
 * 			String getName()返回该线程的名称
 * 		2.可以先获取当前正在执行的线程，使用该线程中的方法getName()获取线程的名称
 * 			static Thread currentThread()返回当前正在执行的线程对象的引用
 * */
public class ThreadName extends Thread {
	@Override
	public void run(){
		/*获取线程名称 方法一
		String name = getName();
		System.out.println(name);
		*/
		
		//方法二 获取当前正在运行的线程，在获取名称
		Thread currentThread = Thread.currentThread();
		String name2 = currentThread.getName();
		System.out.println(name2);
		
		//链式编程
		System.out.println(Thread.currentThread().getName());
	}
}

设置线程名称（了解）

/*
 * 设置线程的名称（了解）
 * 	1.使用Thread类中的方法setName(名字)
 * 		void setName(String name)改变线程名称，使之与参数name相同
 * 	2.创建一个带参数的构造方法，参数传递线程的名称；调用父类的带参构造方法，把线程名称传递给父类，让父类（Thread）给子类线程起一个名字
 * 		Thread(String name)分配新的Thread对象
 * */
public class SetThreadName extends Thread {
	//有参无参构造器
	 public SetThreadName() {
	}
	 public SetThreadName(String name) {
		 super(name);
		}
	@Override
	public void run(){
		System.out.println(Thread.currentThread().getName());
	}

}

public class Test3 {
	public static void main(String[] args) {
		//方式一
		SetThreadName s = new SetThreadName();
		s.setName("张三");
		s.start();
		
		//方式二
		SetThreadName s2 = new SetThreadName("李四");
		s2.start();
	}
}

线程的方法——sleep

/*
 * public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）
 * 毫秒数结束之后，线程继续执行
 * */
public class Test4 {
	public static void main(String[] args) {
		for(int i=1;i<20;i++){
			System.out.println(i);
			//每隔1秒打印出一次
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

多线程创建的方式二————实现Runnable接口

实现Runnable接口创建多线程程序的好处：

避免了单继承的局限性：一个类只能继承一个类（一个人只能有一个父亲），类继承了Thread类就不能继承其他的类，实现了Runnable接口，还可以继承其他的类，实现其他的接口

增强了程序的扩展性，降低了程序的耦合性（解耦）：实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离（解耦）：实现类中，重写了run方法：用来设置线程任务；创建Thread类对象，调用start方法：用来开启新的线程

/*
 * 创建多线程的方式二：实现Runnable接口
 * java.lang.Runnable
 		Runnable接口应该由那些打算通过某一线程执行其实力的类来实现。类必须定义一个称为run的无参数方法。
 * java.lang.Thread类的构造方法
        Thread(Runnable target) 分配新的 Thread 对象。
        Thread(Runnable target, String name) 分配新的 Thread 对象。
        
 * 实现步骤：
 * 	1：创建一个Runnable接口的实现类
 * 	2：在实现类中重写Runnable接口的run方法，设置线程任务
 * 	3：创建一个Runnable接口的实现类对象
 * 	4：创建Thread类对象，构造方法中传递Runnable接口的实现类对象
 * 	5：调用Thread类中的start方法，开启新的线程执行方法run方法      
 * */
public class Test5 implements Runnable {
	@Override
	public void run(){
		for (int i = 0; i < 20; i++) {
			System.out.println(Thread.currentThread().getName()+"***"+i);
		}
	}
}

public class ImpTest5 {
	public static void main(String[] args) {
		Test5 t = new Test5();
		Thread thread = new Thread(t);
		thread.start();
		
		for (int i = 0; i < 20; i++) {
			System.out.println(Thread.currentThread().getName()+"***"+i);
		}
	}
}

匿名内部类创建多线程

/*
 * 匿名内部类实现线程的创建
 * 
 * 匿名：没有名字
 * 内部类：写在其他类内部的类
 * 
 * 匿名内部类作用：简化代码
 * 	  把子类继承父类，重写父类的方法，创建子类对象一步完成
 * 	 把实现类实现接口，重写接口中的方法，创建实现类对象合成一步完成
 * 匿名内部类的最终产物：子类/实现类对象，而这个类没有名字
 * 
 * 格式：
 * 		new 父类/接口（）{
 * 			重写父类/接口中的方法	
 * 		}；
 * */
public class Test6 {
	public static void main(String[] args) {
		//new 父类
		new Thread(){
			@Override
			public void run(){//重写run方法
				for (int i = 0; i < 20; i++) {
					System.out.println(Thread.currentThread().getName());
				}
			}
		}.start();;
		
		//new 接口
		Runnable runnable = new Runnable() {
			
			@Override
			public void run() {//重写run方法
				for (int i = 0; i < 20; i++) {
					System.out.println(Thread.currentThread().getName()+"*");
				}
				
			}
		};
		new Thread(runnable).start();;
	}
}

线程安全问题

多个线程访问一个共享数据，容易出现线程安全问题

线程安全问题解决方式一————同步代码块 synchronize

/*
 * 卖票案例出现了线程安全问题
 * 卖出了不存在的票和重复的票
 * 
 * 解决线程安全问题的第一种方案：使用同步代码块
 * 格式：
 * 		synchronize(锁对象){
 * 			可能会出现线程安全问题的代码（访问了共享数据的代码）
 * 		}
 * 注意:
 * 	  1.通过代码块中的锁对象，可以使用任意的对象
 * 	  2.但是必须保证多个线程使用的锁对象是同一个
 * 	  3.锁对象作用：
 * 			   把同步代码块锁住，只让一个线程在同步代码块中执行
 * */
public class SynchronizeDemo implements Runnable{
	//定义出售票的数量为100
	 int ticket =100;
	
	//定义锁的对象
	Object obj = new Object();
	
	@Override
	public void run(){
		while(true){
			synchronized(obj){
				if(ticket>0){
					System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张");
					ticket--;
				}
			}
		}
	}
}

public class Test7 {
	public static void main(String[] args) {
		SynchronizeDemo s = new SynchronizeDemo();
		Thread t1 = new Thread(s);
		Thread t2 = new Thread(s);
		Thread t3 = new Thread(s);
		t1.start();
		t2.start();
		t3.start();
	}
}

 同步代码块产生的原理

线程安全问题解决方式二————同步方法

/*
 * 卖票案例出现了线程安全问题
 * 卖出了不存在的票和重复的票
 * 
 * 解决线程安全问题的第二种方案：使用同步方法
 * 使用步骤：
 * 		1.把访问了共享数据的代码抽取出来，放到一个方法中
 * 		2.在方法上添加synchronized修饰符
 * 
 * 格式：定义方法的格式
 * 修饰符 synchronized 返回值类型 方法名(参数列表){
 * 			可能会出现线程安全问题的代码（访问了共享数据的代码）
 * 		}
 * */
public class Demo1 implements Runnable
{  int ticket=100;

	@Override
	public void run() {
		while(true){
			//调用同步方法
			paycheck();
		}
	}	
		/*
		 * 定义一个同步方法
		 * 同步方法也会把方法内部的代码锁住
		 * 只让一个线程执行
		 * 同步方法的锁对象是谁？
		 * 		也就是实现类对象 new RunnableImple()
		 * 		也就是this
		 * */
		public synchronized void paycheck(){//将共享的数据的方法写在同步方法来
			if(ticket>0){
				System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张");
				ticket--;
			}
			/*synchronized (this) {
				if(ticket>0){
					System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张");
					ticket--;
				}
			}*/
		}
		
		/*
		 * 静态的同步方法（了解）
		 * 所对象是谁？
		 * 	不能是this 
		 * 	this是创建对象之后产生的，静态方法优先于对象
		 * 	静态方法的锁对象是本类的class属性——>class文件对象(反射)
		 * */
		public static synchronized void staticPayCheck(){
			if(ticket>0){
				System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张");
				ticket--;
			}
			
			/*synchronized (Demo1.class) {
				if(ticket>0){
					System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张");
					ticket--;
				}
			}*/
		}
}

线程安全问题解决方式二————Lock锁

/*
 * 卖票案例出现了线程安全问题
 * 卖出了不存在的票和重复的票
 * 
 * 解决线程安全问题的第三种：使用Lock锁
 * java.util.concurrent.locks.Lock接口
 * Lock 实现提供了比使用synchronize 方法和语句可获得更广泛的锁定操作
 * Lock接口中的方法：
 * 		void lock()获取锁
 * 		void unlock() 释放锁
 * java.util.concurrent.locks.ReentrantLock implements Lock 接口
 * 
 * 使用步骤：
 * 		1.在成员位置创建一个ReentrantLock对象
 * 		2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
 * 		3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁
 * */
public class Demo2 implements Runnable {
	//定义有100张票
	int ticket=100;
	
	//创建一个ReentrantLock对象
	ReentrantLock r = new ReentrantLock();
	
	@Override
	public void run() {
		while(true){
			//开启锁
			r.lock();
			if(ticket>0){
				System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张");
				ticket--;
			}
			r.unlock();
		}
	}
	
}

public class Test9 {
	public static void main(String[] args) {
		Demo2 d = new Demo2();
		Thread t1 = new Thread(d);
		Thread t2 = new Thread(d);
		Thread t3 = new Thread(d);
		t1.start();
		t2.start();
		t3.start();
	}
}