黑马程序员------多线程（No.1）（概述、线程的创建、安全问题、同步锁、同步函数）

最新推荐文章于 2021-06-17 13:45:01 发布

硅与神经键

最新推荐文章于 2021-06-17 13:45:01 发布

阅读量1k

点赞数

分类专栏： Java SE 牛刀小试文章标签：对象 java 线程同步锁同步函数

本文链接：https://blog.csdn.net/helloxiaobi/article/details/11629659

版权

Java SE 牛刀小试专栏收录该内容

28 篇文章 0 订阅

订阅专栏

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------

概述

进程：是一个正在执行中的程序。每一个进程都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。

线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。

一个进程中至少有一个线程。

Java VM 启动的时候会有一个进程java.exe。

该进程中至少一个线程负责java程序的执行。

而且这个线程运行的代码存在与main方法中。

该线程称之为主线程。

扩展：其实更细节说明jvm，jvm启动不止一个线程，还有负责垃圾回收机制的线程。

1.如何在自定义的代码中，自定义一个线程呢？

//继承Thread类，重写run方法。
class Demo extends Thread{
	public void run(){
		for(int x = 0;x<30;x++){
			System.out.println("demo run.."+x);
			}	
	}
}
class ThreadDemo{
	public static void main(String[] args){
		Demo d = new Demo();//创建好一个线程
		d.start();
		for(int x = 0;x<30;x++){
			System.out.println("Main run.............."+x);
			}
	}
}

运行结果，及分析：

为什么要覆盖run方法：

Thread用于描述线程，该类定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法。

也就是说Thread类中的run方法，用于存储线程要运行的代码

d.run();//仅仅是对象的调用方法，而线程创建了，并没有运行。

d.start();//开启线程，并执行该线程的run方法。

线程的运行状态：

每个线程都有自己默认的名称。

Thread-编号该编号从0开始。

static Thread currentThread();获取当前线程对象。

getName();获取线程的名称。

设置线程名称：setName或者构造函数。

class Demo extends Thread{
	private String msg;
	Demo(String msg){
		super(msg);
	}
	public void run(){
		for(int x = 0;x<30;x++){
			//currentThread();获取当前线程对象。
			//getName();获取线程的名称。
			System.out.println(Thread.currentThread().getName()+" "+x);
			}	
	}
}
class ThreadDemo{
	public static void main(String[] args){
		Demo d1 = new Demo("线程一");//创建好一个线程
		d1.start();
		Demo d2 = new Demo("线程二");
		d2.start();
	}
}

有关售票的练习程序：

/*
简单的卖票程序
多个窗口买票
*/
class Ticket extends Thread{
	private static int tick = 10;
	public void run(){
		while(true){
			if(tick>0){
				System.out.println(currentThread().getName()+"sale: "+tick--);
			}
		}
	}
}
public class TicketDemo{
	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();
	}
}

运行结果

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

步骤：

1.定义类实现Runnable接口

2.覆盖Runnable接口中的run方法。将线程要运行的代码放在该run方法中。

3.通过Thread类建立线程对象。

4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。

为什么要将Runnable接口的子类对象传递给Thread的构造函数？

因为，自定义run方法所需要的对象是Runnable接口的子类对象，所以要让线程去指定指定对象的run方法。

5.调用Thread类的start方法开启线程并调用Runnable接口的子类的run方法。

/*
简单的卖票程序
多个窗口买票
*/
//定义类实现Runnable接口
class Ticket implements Runnable{
	private static int tick = 10;
	//覆盖Runnable接口中的run方法。将线程要运行的代码放在该run方法中
	public void run(){
		while(true){
			if(tick>0){
				System.out.println(Thread.currentThread().getName()+"sale: "+tick--);
			}
		}
	}
}
public class TicketDemo{
	public static void main(String[] args){
		//创建Runnable接口的子类对象
		Ticket t = new Ticket();
		//通过Thread类建立线程对象。
		//将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

实现方式和继承方式有什么区别？

实现方式好处：避免单继承的局限性。在定义线程时，建议使用实现方式。

两种方式的区别：

继承Thread：线程代码存在Thread子类的run方法中。

类实现Runnable：线程代码存在接口的子类的run方法。

多线程的安全问题

如果程序如下

class Ticket implements Runnable {
	Object obj = new Object();
	private static int tick = 150;
	//覆盖Runnable接口中的run方法。将线程要运行的代码放在该run方法中
	public void run(){
		while(true){
			if(tick>0){
				try
				{
					Thread.sleep(10);//sleep10ms;
					System.out.println(Thread.currentThread().getName()+"sale: "+tick--);
				}
				catch (InterruptedException e)
				{
				}
			}
			
		}
	}
}
public class TicketDemo{
	public static void main(String[] args){
		//创建Runnable接口的子类对象
		Ticket t = new Ticket();
		//通过Thread类建立线程对象。
		//将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

问题的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，
另一个线程参与进来执行，导致共享数据出错。

解决办法：对多条操作共享数据的语句，只能让一个线程都执行完毕；在执行过程中，其他线程不允许执行。

Java对多线程的安全问题提供了专业的解决方式----同步代码块：

synchronized(对象){
需要被同步的代码
}

解决安全问题后的代码：

/*
问题的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，
另一个线程参与进来执行，导致共享数据出错。

解决办法：对多条操作共享数据的语句，只能让一个线程都执行完毕；在执行过程中，其他线程不允许执行。

Java对多线程的安全问题提供了专业的解决方式----同步代码块：
synchronized(对象){
	需要被同步的代码
}
*/
class Ticket implements Runnable {
	Object obj = new Object();
	private static int tick = 150;
	//覆盖Runnable接口中的run方法。将线程要运行的代码放在该run方法中
	public void run(){
		while(true){
			synchronized(obj){
				if(tick>0){
					try
					{
						Thread.sleep(0);//sleep10ms;
						System.out.println(Thread.currentThread().getName()+"sale: "+tick--);
					}
					catch (InterruptedException e)
					{
					}
				}
			}
		}
	}
}
public class TicketDemo{
	public static void main(String[] args){
		//创建Runnable接口的子类对象
		Ticket t = new Ticket();
		//通过Thread类建立线程对象。
		//将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

synchronized

同步代码块

Java对多线程的安全问题提供了专业的解决方式----同步代码块：

synchronized(对象){
需要被同步的代码
};

synchronized 同步锁。（就像火车洗手间）

对象如同锁，持有锁的线程可以在同步中执行。

没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有锁。

同步的前提：

1.必须要有两个或者两个以上的线程。

2.必须是多个线程使用同一个锁。

3.必须保证同步中只能有一个线程在运行。

好处：解决了多线程的安全问题。

弊端：多个线程每次都要判断锁，较为消耗资源咯（是在允许范围内的）。

同步函数

需求：
银行有一个金库。两个储户分别存300元，每次100，存3次。

目的：找到改程序的安全问题，以及如何解决？

/*
需求：
银行有一个金库。两个储户分别存300元，每次100，存3次。

目的：找到改程序的安全问题，以及如何解决？
*/
class Bank{
	private int sum;
	public void add(int n){
		try{
			sum = sum+n;
			Thread.sleep(10);
			System.out.println("sum="+sum);
		}catch(Exception e){}
	}
}
class Cus implements Runnable{
	private Bank b = new Bank();
	public void run(){
		for(int x=0;x<3;x++){
			b.add(100);
		}
	}
}
class BankDemo{
	public static void main(String[] args){
		Cus cus = new Cus();
		Thread t1 = new Thread(cus);
		Thread t2 = new Thread(cus);
		t1.start();
		t2.start();
	}
}

输出结果出现问题：

class Bank{
	private int sum;
//	Object obj = new Object();
	public synchronized void add(int n){
	//	synchronized(obj){
			sum = sum+n;
			try{
				Thread.sleep(10);
			}catch(Exception e){}
			System.out.println("sum="+sum);
	//	}
	}
}
class Cus implements Runnable{
	private Bank b = new Bank();
	public void run(){
		for(int x=0;x<3;x++){
			b.add(100);
		}
	}
}
class BankDemo{
	public static void main(String[] args){
		Cus cus = new Cus();
		Thread t1 = new Thread(cus);
		Thread t2 = new Thread(cus);
		t1.start();
		t2.start();
	}
}

输出正确结果：

同步函数用的是哪一个锁呢？
函数需要被对象调用。那么函数都有一个所属对象引用。就是this。
所以同步函数使用的锁是this。

/*
同步函数用的是哪一个锁呢？
函数需要被对象调用。那么函数都有一个所属对象引用。就是this。
所以同步函数使用的锁是this。
*/
class Ticket implements Runnable {
	Object obj = new Object();
	private static int tick = 150;
	//覆盖Runnable接口中的run方法。将线程要运行的代码放在该run方法中
	public void run(){
		while(true){
			//将需要被锁的代码抽取成功能 public synchronized void show()
			this.show();
		}
	}
	//定义同步锁功能，该锁是this。
	public synchronized void show(){
		if(tick>0){
			try{
				Thread.sleep(10);//sleep10ms;
				System.out.println(Thread.currentThread().getName()+"sale: "+tick--);
				}
				catch (InterruptedException e){
				}
		}
	}
}
public class ThisLockDemo{
	public static void main(String[] args){
		//创建Runnable接口的子类对象
		Ticket t = new Ticket();
		//通过Thread类建立线程对象。
		//将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

如果同步函数被静态修饰后，使用的锁是什么呢？

通过验证，发现不再是this。因为静态方法中也不可以定义this。

静态近内存时，内存中没有本类对象，但是一定有笨类对应的字节码文件对象。

类名.class 该对象的类型是Class。

静态的同步方法，使用的锁是该方法所在类的字节码文件对象，类名.class。

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

详情请查看：http://edu.csdn.net

硅与神经键

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员------多线程（No.1）（概述、线程的创建、安全问题、同步锁、同步函数）

概述进程：是一个正在执行中的程序。每一个进程都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。一个进程中至少有一个线程。 Java VM 启动的时候会有一个进程java.exe。该进程中至少一个线程负责java程序的执行。而且这个线程运行的代码存在与main方法中。该线程称之为主线程
复制链接

扫一扫