Java 多线程—上篇

其他 2019-03-15 20:41:04 阅读次数: 0

多线程简介

简单概念： Ctrl+Alt+Del(也就是在0数字旁边的.)看到进程了嘛！进程里面执行的程序里面就有很多的线程，当然你是看不到的懂吗？这都是编写代码的时候，程序员写的。当然你看过你打开软件的时候跳出了另外一个软件（也就是广告）吗？这就是又创建了一个进程，而这个进行里面有很多的线程，不是同时执行的哦，只是CPU在做着快速的切换。

多线程概述

  1. 进程： 是一个正在执行的程序

    每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元（线程）。

  2. 线程： 就是进程中的一个独立的单元

    线程控制着进程的执行

    一个进程中，至少有一个以上的线程

  3. Java JVM 启动的时候会有一个进程 Java.exe

    1. 该进程中至少有一个（当让就是多个）线程负责 Java 程序的执行。
    2. 而且这个线程运行的代码存在于 main 方法中
    3. 该线程称为主线程

开始进入状态

创建线程：

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

步骤：

  1. 定义类继承Thread。

  2. 复写Thread类中的run方法

    目的：将自定义代码存储在run方法。让线程运行。

  3. 调用线程的start方法，该方法两个作用：启动线程，调用run方法。

    （如果直接调用run方法也不是不可以，但是就和多线程无关了）

代码示例：

//	1.定义类继承Thread
public class ThreadDemo1 extends Thread {
//	2.复写Thread类中的run方法
	@Override
	public void run() {
//		3.目的：将自定义代码存储在run方法
		//线程运行代码
		super.run();
	}
}

public class ThradTest1 {
	public static void main(String[] args) {
//		4.创建子类对象
		ThreadDemo1 td = new ThreadDemo1();
//		5.启动线程
		td.start();
	}
}

简化格式：

class Test{ 
	public static void main(String[] args){ 
		new Thread(){ 
			public void run(){ 
				//线程运行代码; 
			} 
		}.start(); 
	} 
}

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

步骤：

  1. 定义类Runnable接口
  2. 覆盖Runable接口中的run方法。将线程要运行的代码存放再改run方法中
  3. 通过Thread类建立线程对象。
  4. 将Runable接口的子类对象作为实际参数传递给Thread类的构造函数
  5. 调用Thread类的start方法开启线程并调用Runnable接口子类的run方法

代码示例：

//	1.定义类实现Runnable接口
public class RunnableDemo1 implements Runnable {
//	2.覆盖Runnable接口中的run方法。将线程要运行的代码存放在该run方法中
	@Override
	public void run() {
		//线程运行代码
	}
}

public class RunnableTest {
	public static void main(String[] args) {
//		3.通过Thread类建立线程对象
		RunnableDemo1 rd = new RunnableDemo1();
//		4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数
		Thread t = new Thread(rd);
//		5.调用Thread类的start方法开启线程并调用Runnable接口子类的run方法
		t.start();
	}
}

简化格式：

class Test{ 
	public static void main(String[] args){ 
		new Thread(new Runnable(){ 
			public void run(){ 
				//线程运行代码; 
			} 
		}).start(); 
	} 
}
  • 为什么要将Runnable接口的子类对象传递给Thread的构造函数。
  • 因为，自定义的run方法所属的对象是Runnable接口的子接口对象。所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。

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

(1)、实现方式好处：避免了单继承的局限性

(2)、在定义线程时：建议使用实现方式

(3)、两种方式区别：

  1. 继承Thread：线程代码存放在 Thread 子类 run 方法中
  2. 实现Runnable：线程代码存放在接口的子类的 run 方法中

总结建议： 建议使用第二种线程创建方法。因为第二种方式更加体现面向对象思想。

多线程练习题

/*继承Thread类*/
public class ThreadDemo3 extends Thread {
	@Override
	public void run() {
        //打印当前线程名和10个aaa
		for (int i = 0; i < 20; i++) {
			System.out.println(getName()+"aaa");
		}
		super.run();
	}
}

public class ThreadTest3 {
	public static void main(String[] args) {
        //创建线程对象
		ThreadDemo3 td = new ThreadDemo3();
        //启动线程
		td.start();
		//创建新的线程并打印线程名和bbb，此线程为主线程
		for (int i = 0; i < 20; i++) {
             //System.out.println(this.getName()+"bbb");
			System.out.println(Thread.currentThread().getName()+"bbb");
             /*注意：获取线程对象名称时，不建议使用this，为什么，因为不怎么通用， 
			不过Thread.currentThread().getName()这个方法就是通用的。*/ 
		}
		
	}
}

运行以上代码后，我们可以分析出一些问题：

多线程好处：

原本我们如果是单线程的情况下，我们定义在死循环就一直运行死循环的代码，不会运行其他的代码。

多线程的好处就体现出来了，他可以让我们的代码实现同步运行

发现运行结果每一次都不同。

因为多个线程都获取CPU的执行权。CPU执行到谁，谁就运行。

明确一点，在某一个时刻，只能有一个程序在运行。(多核除外)

CPU在做着快速的切换，以达到看上去是同时运行的效果。

我们可以形象把多线程的运行行为在互相抢夺CPU的执行权。

这就是多线程的一个特性：随机性。谁抢到谁执行，至于执行多长，CPU说的算。

为什么要覆盖run方法：

Thread类用于描述线程。

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

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

线程有名字吗？

从运行的代码来看，原来线程都有自己默认的名称。

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

主线程有名字吗？

从运行的代码来看，主线程也有自己的名字就是main

线程(Thread)类中已经封装好的方法：

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

getName(): 获取线程名称。

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

**注意：**主线程不会设置名称，它的线程名是默认的(main);

用多线程做一个多窗口卖票系统。

	/*
	需求：
	简单的卖票程序，多个窗口卖票。 
	思路：
	票是一个共享数据被多个窗口所操作。 
	窗口是一个线程，多个窗口应该是一个多线程。 
	步骤：
	票，是共享数据，应该被static修饰起来。 
	多窗口，是多线程，应该创建多个线程来操作票。 
	*/ 
public class Ticket extends Thread {
	/*把线程创建传递进来的名字丢给父类带参数的构造函数*/
	public Ticket(String ThreadName) {
		super(ThreadName);
	}
	/*定义票数据，定义为共享数据，因为多个窗口卖的是同一个票资源*/ 
	private static int tick = 100;
	@Override
	public void run() {
		while(true){
			/*如果还有票就打印下几号客户在买票，然后卖出去一张票，减一张票*/ 
			if(tick > 0){
				System.out.println(tick+"号客户买票\n"+Thread.currentThread().getName()+"为"+tick+"号客户服务\t卖第"+tick--+"票");
			}else{
				/*如果没有票了，就向客户致敬，然后跳出return跳出循环，方法结束*/ 
				System.out.println(Thread.currentThread().getName()+"票已售完");
				return;
			}
		}
	}
}

public class TicketTest {
	public static void main(String[] args) {
//		创建匿名线程对象，调用对象的start()方法。
		new Ticket("1号窗口").start();
		new Ticket("2号窗口").start();
		new Ticket("3号窗口").start();
		new Ticket("4号窗口").start();
	}
}

在多窗口卖票系统中：

通过分析，发现，多窗口打印同一张票或者打印出0，-1，-2等错票。

多线程的运行出现了安全问题。

问题的原因：

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分（CPU就切换到另外的线程去），还没有执行完，另一个线程参与进来执行。导致共享数据的错误。

解决办法：

对多条操作共享数据的语句，让一个线程都执行完。在执行过程中，其他线程不可以参与执行。

Java对于多线程的安全问题提供了专业的解决方式，就是同步代码块。

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

同步代码块

  • 用synchronized关键字来进行定义。

同步代码块格式

synchronized(唯一对象){ 
	需要被同步的代码; 
} 
/* 
	对象如同锁，持有锁的线程可以在同步中执行。 
	没有持有锁的线程即使获取CPU的执行权，也进不去，因为没有获取锁。
*/

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

弊端： 多个线程需要判断锁，较为消耗资源，

同步的前提：

  1. 必须要有两个或者两个以上的线程。
  2. 必须是多个线程使用同一个锁。

我们用同步代码块重新编写这段程序

public class Ticket1 implements Runnable {
	/*定义票数据，因为创建的是一个对象资源，所以保证了数据的共享，不用static也可以*/ 
	private static int tick = 100;
	@Override
	public void run() {
		while(true){
			synchronized(this){
				/*如果还有票就打印下几号客户在买票，然后卖出去一张票，减一张票*/ 
				if(tick > 0){
					try {
						/*由于考虑到如果客户有可能操作慢而导致延迟，所以加入线程延迟进行测试，我们是程序员必须要做到一些错误的排除，当然不能保证到万无一失，但也要做到尽量避免发生错误*/
						Thread.sleep(10);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println(tick+"号客户买票\n"+Thread.currentThread().getName()+"为"+tick+"号客户服务\t卖第"+tick--+"票"); 
				}else{
					/*如果没有票了，就向客户致敬，然后跳出return跳出循环，方法结束*/ 
					System.out.println(Thread.currentThread().getName()+":票已售完"); 
					return;
				}
			}
		}
	}	
}

public class TicketTest1 {
	public static void main(String[] args) {
		/* 
		这时要设置线程的名字的话，就要用Thread类的方法了，因为Runnable是 
		父接口，而设置线程的方法是在Thread类中的，所以可以直接用Thread对象调用。 
		*/ 
		Ticket1 t = new Ticket1();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);
		
		t1.setName("第1号窗口");
		t2.setName("第2号窗口");
		t3.setName("第3号窗口");
		t4.setName("第4号窗口");
		
		t1.start();
		t2.start();
		t3.start();
		t4.start();

		/*创建线程对象，把资源当成参数进行传递（保证了资源的唯一），调用Thread类的start()方法。*/ 
	}
}

从程序上看就解决了线程的同步问题，但是问题就来了，同步的锁是什么呢？

锁可以是任意对象，我们创建了一个对象，结果解决了问题。

但是这个问题是什么呢？

通过以上程序的测试，发现同步代码块使用的锁是this。

直观分析：

由于同步代码块使用的锁是任意对象，很直观就可以想到函数是需要被对象调用才执行的。

那么函数都有一个所属对象引用。就是this。

但这个对象是怎么传递进来的呢？

原来是调用函数的时候，函数内持有一个函数对象的引用。

那我们可不可以把同步定义在函数上？

答案是：…可以的。结果就有了同步函数。

同步函数：

  • 所谓的同步函数就是在函数的返回值前面加一个synchronized关键字就是同步函数了。

使用同步函数注意事项：

  • 一定要明确哪个代码是需要进行同步，如果同步函数中的代码都是需要同步的，就可以使用同步函数。

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

因为静态方法中也不可以定义this。所以很直观就把this去掉了。

但是这个对象又是谁呢？

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

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

单例设计模式之懒汉式

  • 对象是方法被调用时才初始化，也叫对象的延时加载
  • Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。
class Single{ 
	private Single(){} 

	private static Single single = null; 

	public  staticSingle getInstance(){ 
		//避免每次都判断锁，只有当对象为null的情况下才判断 
		if(single==null){
			synchronized(Single.class){ 
				/*如果一个线程跑到第一个if后死了，另一个线程进来创建了对象释放了锁，然后那个线程醒了，进来后还要判断*/ 
				if(single==null)
					single =new Single(); 
			} 
		} 
		return single; 
	} 
}

线程同步注意的问题：

  • 由于线程同步代码中可能嵌套同步，最容易导致的问题就是死锁。程序就停在那里不动了。
  • 我们作为程序员，我应该尽量避免死锁的出线。

死锁代码：

public class MyLock {
	public static Object locka = new Object();
	public static Object lockb = new Object();
}

public class DeadLockTest implements Runnable {
	private boolean flag;
	public DeadLockTest(boolean flag) {
		super();
		this.flag = flag;
	}
    
	@Override
	public void run() {
		if(flag){
			while(true){
				synchronized(MyLock.locka){
					System.out.println(Thread.currentThread().getName() + "...if locka "); 
					synchronized(MyLock.lockb){
						System.out.println(Thread.currentThread().getName() + "...if lockb "); 
					}
				}
			}
		}else{
			while(true){
				synchronized(MyLock.lockb){
					System.out.println(Thread.currentThread().getName() + "...if lockb "); 
					synchronized(MyLock.locka){
						System.out.println(Thread.currentThread().getName() + "...if locka "); 
					}
				}
			}
		}
	}
}

public class Test {
	public static void main(String[] args) {
		Thread t1 = new Thread(new DeadLockTest(true));
		Thread t2 = new Thread(new DeadLockTest(false));
		
		t1.start();
		t2.start();
	}
}

猜你喜欢

转载自blog.csdn.net/weixin_43650254/article/details/84928767
今日推荐
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
周排行
curl的POST请求，封装方法
8.1.1. Integer Types
Java基础 Day05(个人复习整理)
Python - Django - 中间件 process_exception
小L的试卷
【Shell编程】 （函数）判断用户是否存在
python(css样式)
spring ant path 匹配原则 - 【笔记】
《JavaScript与JScript从入门到精通》(美)James.Jaworski.中译本.扫描版.pdf
Eclipse运行带参数的java程序
每日归档
更多
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022