深入理解Java多线程-CSDN博客

本文链接：https://blog.csdn.net/wangpanbaoding/article/details/9124381

------- android培训、java培训、期待与您交流！ ----------

一，创建线程的第一种方式：继承Thread类

线程的一些小知识

package fighting;

public class ThreadDemo {

	/**
	 * 线程：
	 * 创建线程的第一种方式：继承Thread类。
	 * 步骤：
	 * 1，定义类继承Thread。
	 * 2，复写Thread类中的run方法。
	 *    目的是将自定义代码存储在run方法，让线程执行。
	 * 3，调用线程的start方法，该方法两个作用：启动线程，调用run方法。
	 * 
	 * 这个程序有两个线程：主线程和mt线程
	 * 解析：主线程由虚拟机创建，主线程先开启，主线程往下运行，运行到①②的时候，主线程会创建mt这个线程，
	 *       然后启动mt线程，接着主线程继续往下执行那个循环语句。此时两个线程交互执行，所以结果会出现交互的log
	 * 注意：运行结果每一次都不同，因为多个线程都获取CPU的执行权。CPU执行到谁，谁就运行。
	 * 明确一点：在某一个时刻，只能有一个程序在运行(多核除外)。CPU做着飞速的切换，以达到看上去程序是同时运行的效果。
	 * 这就是多线程的一个特性：随机性。
	 * 如果是双核的，就可以一个CPU处理一个。双核CPU的话，内存是瓶颈。内存足够大，才能体现双核执行程序速度快的优势。
	 * 
	 * 总结：线程执行的是Thread类中的run方法里的代码。Thread类时由主线程创建。
	 *      主线程执行的main方法里的代码。主线程由JVM创建。
	 */
	public static void main(String[] args) {
		MyThread mt = new MyThread();//①
		//线程的start方法有两个作用：启动线程，调用run方法
		mt.start();//②
		//注意：直接调用run方法，那就仅仅是对象调用方法了，而线程创建了，并没有开启运行，这样run里的代码是主线程执行的，
		//而不是Thread类执行的了。
		//直接调用run方法执行的结果就是：主线程执行完run里的60次循环，才会接着执行下面的Hello world的60循环。
//		mt.run();
		
		for(int i=0;i<60;i++){
			System.out.println("Hello world " +i);
		}
		
	}

}

class MyThread extends Thread{
	public void run(){
		for(int x=0;x<60;x++){
			System.out.println("thread run " + x);
		}
	}
}

二，线程的小练习：

知识点：线程都有自己的默认的名称，可以用getName方法直接获取。

package fighting;

public class ThreadDemo2 {

	/**
	 * 线程小练习
	 * 获取线程对象以及名称
	 * 线程都有自己的默认的名称。getName方法可以获取。
	 * 
	 * static Thread currentThread()：获取当前线程对象。
	 * 
	 * 设置线程名称：setName或者构造函数传参的方式都可以
	 */
	public static void main(String[] args) {
		MyThread2 mt1 = new MyThread2("one");
		MyThread2 mt2 = new MyThread2("two");
		mt1.start();
		mt2.start();

		for(int x=0;x<60;x++){
			System.out.println("主线程..."+x);
		}
	}

}

class MyThread2 extends Thread{
//	private String name;
	public  MyThread2(String name){
//		this.name=name;
		//Thread类自身有传递线程名称的构造方法，可以调用父类的构造方法
		super(name);
	}
	public void run(){
		for(int x = 0;x<60;x++){
			/**
			 * 注意：线程0和线程1都进来了，它们的x是一个x吗？
			 * 不是，局部变量，在每一个线程区域都有独立的一份。
			 */
			System.out.println(Thread.currentThread()==this);
			System.out.println(this.getName()+" run..."+x);
		}
	}
}

三，创建线程的第二种方式：实现Runnable接口

线程的安全问题：同步代码块方式解决。

同步的前提，同步的好处，同步的弊端。

package fighting;

public class ThreadDemo3 {

	/**
	 * 需求：简单的卖票程序。多个窗口同时卖票。
	 * 注意：一个线程只要启动一次就可以，没有必要再次启动。多次调用start方法，会报异常java.lang.IllegalThreadStateException
	 * 
	 * 创建线程的第二种方式：实现Runnable接口
	 * 步骤：
	 * 1，定义类实现Runnable接口
	 * 2，覆盖Runnbale接口中的run方法
	 *    目的：将线程要运行的代码存放在run方法中
	 * 3，通过Thread类建立线程对象
	 * 4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数
	 *    为什么要将Runnable接口的子类对象传递给Thread的构造函数？
	 *    因为自定义的run方法所属的对象是Runnable接口的子类对象，
	 *    所以要让线程去执行指定对象的run方法，即必须明确该run方法所属对象。
	 * 5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法
	 * 
	 * 
	 * 总结：实现方式和继承方式有什么区别？
	 *      实现方式好处在于避免了单继承的局限性，在定义线程时，建议使用实现方式。
	 *      资源也可以独立共享。
	 *      
	 * 线程的安全问题：
	 * 解决办法：对多条操作共享数据的语句，只能让一个线程都执行完，再让其他线程执行。
	 * 第一个线程执行的过程中，其他线程禁止执行。
	 * 同步代码块：
	 * synchronized(对象){
	 * 	需要被同步的代码
	 * }  
	 * synchronized有个参数是对象，这个对象如同锁，持有锁的线程可以在同步中执行。
	 * 没有持有锁的线程即使后去CPU的执行权，也进不去，因为没有获取锁。
	 * 
	 * 同步的好处：解决了线程的安全问题。
	 * 
	 * 同步的前提：
	 * 1，必须要有两个或者两个以上的线程
	 * 2，必须是多个线程使用同一个锁。
	 * 同步的弊端：多个线程需要判断锁，较为消耗资源。
	 * 
	 */
	public static void main(String[] args) {
		/*Ticket t1 = new Ticket();
		Ticket t2 = new Ticket();
		Ticket t3 = new Ticket();
		Ticket t4 = new Ticket();
		t1.start();
		t2.start();
		t3.start();
		t4.start();*/
		
		//注意Ticket不是线程，t也不是线程的对象
		//因为只创建了一个Ticket对象，所以下面所有线程共享ticket变量
		Ticket t = new Ticket();
		
		//线程需要和t联系起来才能运行t的run方法里的代码，所以要利用
		Thread t1=new Thread(t);
		Thread t2=new Thread(t);
		Thread t3=new Thread(t);
		Thread t4=new Thread(t);
		//这个start方法调用的是Thread类中的run方法，但是Thread类中的run方法没有自己想要的代码
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}

}
//class Ticket extends Thread{
class Ticket implements Runnable{
	//使用静态变量使得所有线程共享100张票，但是一般不定义静态的，因为静态的生命周期太长
//	private static int ticket =100;
	private int ticket =100;
	public void run(){
		while(true){
			//同步语句块
			synchronized (this) {
				if(ticket>0){
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()+" sale : "+ticket--);
				}else{
					break;
				}
			}
			
			
		}
	}
}

四，解决线程安全问题：同步函数的方法

如何确定需要同步的代码。

package fighting;
/**
 * 需求：
 * 银行有一个金库，有两个储户分别存300元，每次存100元，存3次。
 * 
 * 同步函数的写法:synchronized作为修饰符修饰函数
 * 验证：同步函数的锁是this。
 * 
 * 
 * 如何找问题：
 * 1，明确哪些代码是多线程运行代码：
 *    分析结果：run和add方法里的代码都是
 * 2，明确共享数据：
 *    分析结果：b和sum
 * 3，明确多线程运行代码中哪些语句是操作共享数据的：
 *   分析结果：
 *    操作b的只有一句话，所以不会被不同线程分开操作；
 *    操作sum的有两条语句，可能出现
 */
public class ThreadDemo4 {
	public static void main(String[] args){
		Customer c = new Customer();
		Thread t1 = new Thread(c);
		Thread t2 = new Thread(c);
		t1.start();
		t2.start();
	}
}
class Bank{
	private int sum;
	Object obj = new Object();
	//同步函数：synchronized作为修饰符修饰函数
	public synchronized void add(int n){
			sum = sum+n;
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("sum="+sum);
	}
}

class Customer implements Runnable{
	private Bank b = new Bank();
	public  void run(){
		for(int x=0;x<3;x++){
			b.add(100);
		}
	}
}

五，验证：同步函数的锁是this

package fighting;
/**
 * 验证：同步函数的锁是this。
 * 方法：使用一个flag控制，让两个线程一个进入代码块，一个进入同步函数
 *
 */
public class ThreadDemo5 {
	public static void main(String[] args){

		Ticket1 t = new Ticket1();
		
		Thread t1=new Thread(t);
		Thread t2=new Thread(t);
		
		t1.start();
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t.flag=false;
		t2.start();
	}
}
class Ticket1 implements Runnable
{
	private int ticket =100;
	Object obj = new Object();
	public boolean flag = true;
	public void run(){
			if(flag){
				while(true){
					//同步语句块
//					synchronized (obj) //同步语句块的锁是obj，所以这样会出现错票，因为多个线程必须使用同一个锁才能同步
					synchronized (this)
					{
						if(ticket>0){
							try {
								Thread.sleep(10);
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
							System.out.println(Thread.currentThread().getName()+" sale : "+ticket--);
						}
					}
				}
			}else{
				while(true){
					buy();
				}
			}
			
	}
	public synchronized void buy(){//同步函数的锁是this
		if(ticket>0){
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+" buy : "+ticket--);
		}
	}
}

六，验证：静态同步函数的锁是该方法所在类的字节码文件对象，即类名.class

package fighting;
/**
 * 验证：静态同步函数的锁是该方法所在类的字节码文件对象，即类名.class。
 * 
 * 通过验证，不是this了。因为静态方法中也不可以定义this。
 * 静态方法进入内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。
 * 类名.class  该对象的类型是Class
 * 
 */
public class ThreadDemo6 {
	public static void main(String[] args){

		Ticket2 t = new Ticket2();
		
		Thread t1=new Thread(t);
		Thread t2=new Thread(t);
		
		t1.start();
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t.flag=false;
		t2.start();
	}
}
class Ticket2 implements Runnable
{
	private static int ticket =100;
	Object obj = new Object();
	public boolean flag = true;
	public void run(){
			if(flag){
				while(true){
					synchronized (Ticket2.class)//锁不再是this
					{
						if(ticket>0){
							try {
								Thread.sleep(10);
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
							System.out.println(Thread.currentThread().getName()+" sale : "+ticket--);
						}
					}
				}
			}else{
				while(true){
					buy();
				}
			}
			
	}
	public static synchronized void buy(){//静态同步函数的锁是Class
		if(ticket>0){
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+" buy : "+ticket--);
		}
	}
}

七，单例设计模式：懒汉式和饿汉式

懒汉式中的线程安全问题解决。

package fighting;
/**
 * 单例设计模式：
 * 
 * 饿汉式
 * 懒汉式
 * @author panpan
 *
 */
public class ThreadDemo7 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		

	}

}
//饿汉式
class Single1{
	private static final Single1 s1 = new Single1();
	private Single1(){
	}
	public static Single1 getInstance(){
		return s1;
	}
}
//懒汉式：在多线程操作时会产生安全隐患
//        优势：延迟加载
class Single2{
	private static Single2 s2 = null;
	private Single2(){
	}
	public static Single2 getInstance(){
		if(s2==null){//双重判断可以提高一下效率
			synchronized(Single2.class){
				if(s2==null){
					//不同步的话，这里有安全隐患
					s2=new Single2();
				}
			}
		}
		return s2;
	}
}

八，死锁的小例子：

<p>package fighting;
/**
 * 验证：死锁
 * 两个线程相互需要对方的资源，也都不释放，就会发生死锁
 */
public class ThreadLockDemo {
 public static void main(String[] args){
  Test ta = new Test(true);
  Test tb = new Test(false);
  Thread t1= new Thread(ta);
  Thread t2= new Thread(tb);
  t1.start();
  t2.start();
 }
}
class Test implements Runnable{
 private boolean flag;</p><p> Test(boolean flag){
  this.flag = flag;
 }</p><p> public void run() {
  if(flag){
   synchronized (MyLock.locka) {//MyLock.locka这个锁被ta持有
    System.out.println("if locka");
    synchronized (MyLock.lockb) {
     System.out.println("if lockb");
    }
   }
  }else{
   synchronized (MyLock.lockb) {//MyLock.lockb这个锁被tb持有，ta和tb互相都不释放资源，只好无限期等待
    System.out.println("else lockb");
    synchronized (MyLock.locka) {
     System.out.println("else locka");
    }
   }
  }
  
 }
}
class MyLock{
 static Object locka = new Object();
 static Object lockb = new Object();
}</p>

学习笔记之多线程