Thread详解

最新推荐文章于 2023-06-25 20:16:15 发布
最新推荐文章于 2023-06-25 20:16:15 发布
阅读量1.1k 收藏 2
点赞数
分类专栏： java 基础

1.创建多线程的两种方式：

    1.1 继承Thread方法

class PrintNum extends Thread{
	public void run(){
		//子线程执行的代码
		for(int i = 1;i <= 100;i++){
			if(i % 2 == 0){
				System.out.println(Thread.currentThread().getName() + ":" + i);
			}
		}
	}
	public PrintNum(String name){
		super(name);
	}
}


public class TestThread {
	public static void main(String[] args) {
		PrintNum p1 = new PrintNum("线程1");
		PrintNum p2 = new PrintNum("线程2");
		p1.setPriority(Thread.MAX_PRIORITY);//10
		p2.setPriority(Thread.MIN_PRIORITY);//1
		p1.start();
		p2.start();
	}
}

 

    1.2 实现Runnable接口

//1.创建一个实现了Runnable接口的类
class PrintNum1 implements Runnable {
	//2.实现接口的抽象方法
	public void run() {
		// 子线程执行的代码
		for (int i = 1; i <= 100; i++) {
			if (i % 2 == 0) {
				System.out.println(Thread.currentThread().getName() + ":" + i);
			}
		}
	}
}

public class TestThread1 {
	public static void main(String[] args) {
		//3.创建一个Runnable接口实现类的对象
		PrintNum1 p = new PrintNum1();
//		p.start();
//		p.run();
		//要想启动一个多线程，必须调用start()
		//4.将此对象作为形参传递给Thread类的构造器中，创建Thread类的对象，此对象即为一个线程
		Thread t1 = new Thread(p);
		//5.调用start()方法：启动线程并执行run()
		t1.start();//启动线程；执行Thread对象生成时构造器形参的对象的run()方法。
		
		//再创建一个线程
		Thread t2 = new Thread(p);
		t2.start();
	}
}

两种方式对比：实现的方式优于继承的方式
                           ① 避免了java单继承的局限性；
                           ② 如果多个线程要操作同一份资源(或数据)，更适合使用实现的方式。

2.线程的常用方法：

 2.1.start():启动线程并执行相应的run方法；
 2.2.run():子线程要执行的代码放入run（）方法中；
 2. 3.currentThread():静态的，调取当前线程；
 2.4.getName():获取次线程的名字；
 2.5.setName()：设置此线程的名字。
 2. 6.yield():调用此方法的线程释放当前CPU的执行权；
 2.7.join():在A线程中调用B线程的join()方法，表示：当执行到此方法，A线程停止执行，直到B线程执行完毕，
      A线程再接着join()之后的代码执行；
 2.8.isAlive():判断当前线程是否存活。
 2.9.sleep(long 1):显示的让当前线程睡眠1毫秒；
 2.10.线程通信 Object中的wait();notify();notifyAll()三个方法；
 2.11.设置线程的优先级

3.synchronized字段

  3.1.线程安全问题存在的原因？
    由于一个线程在操作共享数据过程中，未执行完毕的情况下，另外的线程参与进来，导致共享数据存在了安全问题。
    
  3.2.如何来解决线程的安全问题？
      必须让一个线程操作共享数据完毕以后，其它线程才有机会参与共享数据的操作。
  
  3.3.java如何实现线程的安全：线程的同步机制
         
         方式一：同步代码块
        synchronized(同步监视器){
             //需要被同步的代码块（即为操作共享数据的代码）
         }
          1.共享数据：多个线程共同操作的同一个数据(变量)
          2.同步监视器：由一个类的对象来充当。哪个线程获取此监视器，谁就执行大括号里被同步的代码。俗称：锁
             要求：所有的线程必须共用同一把锁！
             注：在实现的方式中，考虑同步的话，可以使用this来充当锁。但是在继承的方式中，慎用this!
 
      方式二：同步方法
        将操作共享数据的方法声明为synchronized。即此方法为同步方法，能够保证当其中一个线程执行
        此方法时，其它线程在外等待直至此线程执行完此方法。
        >同步方法的锁：this

     3.4.线程的同步的弊端：由于同一个时间只能有一个线程访问共享数据，效率变低了。

      方式1：同步代码块

class Window3 extends Thread {
	static int ticket = 100;
	static Object obj = new Object();

	public void run() {
		while (true) {
			// synchronized (this) {//在本问题中，this表示：w1,w2,w3
			synchronized (obj) {
				// show();
				if (ticket > 0) {
					try {
						Thread.currentThread().sleep(10);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()
							+ "售票，票号为：" + ticket--);
				}
			}
		}
	}

	public synchronized void show() {// this充当的锁
		if (ticket > 0) {
			try {
				Thread.currentThread().sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "售票，票号为："
					+ ticket--);
		}
	}
}

public class TestWindow3 {
	public static void main(String[] args) {
		Window3 w1 = new Window3();
		Window3 w2 = new Window3();
		Window3 w3 = new Window3();

		w1.setName("窗口1");
		w2.setName("窗口2");
		w3.setName("窗口3");

		w1.start();
		w2.start();
		w3.start();

	}

}

方式2：同步方法

class Window4 implements Runnable {
	int ticket = 100;// 共享数据

	public void run() {
		while (true) {
			show();
		}
	}

	public synchronized void show() {
		
		if (ticket > 0) {
			try {
				Thread.currentThread().sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "售票，票号为："
					+ ticket--);
		}

	}
}

public class TestWindow4 {
	public static void main(String[] args) {
		Window4 w = new Window4();
		Thread t1 = new Thread(w);
		Thread t2 = new Thread(w);
		Thread t3 = new Thread(w);

		t1.setName("窗口1");
		t2.setName("窗口2");
		t3.setName("窗口3");

		t1.start();
		t2.start();
		t3.start();
	}
}

4.死锁
死锁的问题：处理线程同步时容易出现。
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
写代码时，要避免死锁！

demo：将代码中的两个线程的sleep()取消注释，则出现死锁问题；

public class TestDeadLock {

	static StringBuffer sb1 = new StringBuffer();
	static StringBuffer sb2 = new StringBuffer();

	public static void main(String[] args) {
		new Thread() {
			public void run() {
				synchronized (sb1) {
					try {
					//	Thread.currentThread().sleep(10); 
					} catch (Exception e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					sb1.append("A");
					synchronized (sb2) {
						sb2.append("B");
						System.out.println(sb1);
						System.out.println(sb2);
					}
				}
			}
		}.start();

		new Thread() {
			public void run() {
				synchronized (sb2) {
					try {
						//Thread.currentThread().sleep(10);
					} catch (Exception e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					sb1.append("C");
					synchronized (sb1) {
						sb2.append("D");
						System.out.println(sb1);
						System.out.println(sb2);
					}
				}
			}
		}.start();
	}

}

5.线程的通信：如下的三个关键字使用的话，都得在同步代码块或同步方法中。
wait():一旦一个线程执行到wait()，就释放当前的锁。
notify()/notifyAll():唤醒wait的一个或所有的线程
使用两个线程打印 1-100. 线程1, 线程2 交替打印。

class PrintNum implements Runnable {
	int num = 1;
	Object obj = new Object();
	public void run() {
		while (true) {
			synchronized (obj) {
				obj.notify();
				if (num <= 100) {
					try {
						Thread.currentThread().sleep(10);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + ":"
							+ num);
					num++;
				} else {
					break;
				}
				
				try {
					obj.wait();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

}

public class TestCommunication {
	public static void main(String[] args) {
		PrintNum p = new PrintNum();
		Thread t1 = new Thread(p);
		Thread t2 = new Thread(p);
		
		t1.setName("甲");
		t2.setName("乙");
		
		t1.start();
		t2.start();
	}
}

6.总结案例：

生产者和消费者的问题：

 生产者/消费者问题
  生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，
  店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，
  如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，
  如果店中有产品了再通知消费者来取走产品。

    分析：
    1.是否涉及到多线程的问题？是！生产者、消费者
    2.是否涉及到共享数据？有！考虑线程的安全
    3.此共享数据是谁？即为产品的数量
    4.是否涉及到线程的通信呢？存在这生产者与消费者的通信

class Clerk{//店员
	int product;
	public synchronized void addProduct(){
		if(product>=20){
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}else{
			product++;
			System.out.println(Thread.currentThread().getName()+": 生产了第"+product+"个产品");
			notifyAll();
		}
	}
	public synchronized void consumeProduct(){
		if(product<=0){
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}else{
			System.out.println(Thread.currentThread().getName()+": 消费了第"+product+"个产品");
			product--;
			notifyAll();
		}
	}
	
}
class Producer implements Runnable{
	Clerk clerk;
	public Producer(Clerk clerk){
		this.clerk = clerk;
	}
	public void run() {
		System.out.println("生产者开始生产产品...");
		while(true){
			try {
				Thread.currentThread().sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			clerk.addProduct();
		}
		
	}
	
}
class Customer implements Runnable{
    Clerk clerk;
    public Customer(Clerk clerk ){
    	this.clerk = clerk;
    }
	public void run() {
		System.out.println("消费者开始消费产品");
		while(true){
			try {
				Thread.currentThread().sleep(60);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			clerk.consumeProduct();
		}
		
	}
	
}
public class TestProduceCustome {
	public static void main(String[] args) {
		Clerk clerk = new Clerk();
		Producer  p = new Producer(clerk);
		Customer c = new Customer(clerk);
		Thread t1 = new Thread(p);
		Thread t3 = new Thread(p);
		Thread t2 = new Thread(c);
		t1.start();
		t3.start();
		t2.start();
		
	}

}

7.线程的生命周期：

deyu01
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA线程之Thread类详解
MC的博客
05-30 9万+
ss
Java中Thread详解（一篇就够了）
热门推荐
starsray的博客
05-04 3万+
前言 操作系统中，一个进程往往代表着一个应用程序实例，而线程是进程中轻量级的调度单元，也可以看作是轻量级的进程，可以共享进程资源。下面简单介绍在操作系统中线程通用实现方式。接下来内容主要对线程模型进行简单介绍，然后对Java线程实现Thread类进行了解。 线程模型 暂且抛开Java线程，先说明一下在操作系统中，线程通用的几种实现方式。实现线程主要有三种方式。 内核线程模型 使用内核线程实现的方......
一：深入理解线程 Thread
sco5282的博客
10-25 1252
先了解一下基本概念 1. 程序、进程、线程 程序、进程、线程 程序（静态）：为完成特定的任务，用某种语言编写的一组指令的集合。即：一段静态的代码 进程（动态）：程序的一次执行的过程，或者是正在执行的一个程序。它是一个动态的过程，它有自己的生命周期：产生、存在、消亡。如：运行中的 QQ 进程作为资源分配的单位，系统在运行时会为每个进行分配不同的内存区域 线程：进程可进一步细化为线程，是一个程序内部的一条执行路径 多线程：若一个进程同一时间并行执行多个线程，则是支持多线程的 线程作为调度和执行的单位，
Java多线程基础-4：详解Thread类及其基本用法
wyd_333的博客
04-03 4253
万字详解Java多线程编程类Thread及其基本用法。
Thread类详解
在路上
03-05 2236
Thread类构造方法 创建Thread对象，默认有一个线程名，以Thread-开头，按序增加的数字，从0开始 如果在构造Thread的时候没有传递Runnable或者没有复写Thread的run方法，该Thread不会执行任何东西。 如果构造Thread对象是没有传入ThreadGroup，则默认获取父线程的group作为当前线程的group。此时子线程和父线程在同一个group中 Thre...
rtthread详解
07-28
**rtthread详解** RTThread（Real-Time Thread）是一款开源、小巧、高效且功能强大的实时操作系统（RTOS），适用于物联网（IoT）设备和嵌入式系统。它提供了丰富的组件和服务，如线程管理、内存管理、任务调度、...
C++11 并发指南之std::thread 详解
08-25
"C++11 并发指南之std::thread 详解" 本文主要介绍了 C++11 中的 std::thread 类，它是 C++11 并发指南的重要组件。std::thread 类提供了创建和管理线程的功能，允许开发者在程序中创建多个线程，从而实现并发编程...
RT-Thread详解
10-01
RT-ThreadRT-ThreadRT-ThreadRT-ThreadRT-ThreadRT-Thread
详解C++ thread用法总结
08-18
主要介绍了详解C++ thread用法总结，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Thread类讲解
威威的博客
10-05 1732
详细介绍 Thread 的属性和用法
线程类的构造方法与成员方法
qq_42731393的博客
02-04 297
1.构造方法 public Thread() :分配一个新的线程对象。 public Thread(String name) :分配一个指定名字的新的线程对象。 public Thread(Runnable target) :分配一个带有指定目标新的线程对象。 public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。 2.成员方法 常用方法： public String getName() :获取当前线程名称。 public voi
java Thread两种简单用法总结
weixin_30809333的博客
08-04 2862
方法一： 用继承Thread实现 实例： 代码 package threadtest13;//多线程的写法2，用两种情况变换，//情况1：新建一个对象，两个线程共享一个对象。另外是新建两个对象，两个线程用两个对象//情况2：int i=0；拿到run（）外面与在run（）里面两种情况。//上面4种情况可以排列组合试一下publicclass Thread13 {publicstaticv...
【C++】多线程(thread)使用详解
最新发布
AAADiao的博客
06-25 1万+
多线程（multithreading），是指在软件或者硬件上实现多个线程并发执行的技术。具有多核CPU的支持的计算机能够真正在同一时间执行多个程序片段，进而提升程序的处理性能。在一个程序中，这些独立运行的程序片段被称为“线程”（Thread），利用其编程的概念就叫作“多线程处理”。
Thread类的构造方法及常用方法
wardo_l的博客
02-28 1812
API中java.lang.Thread类定义了有关线程的一些方法，具体如下： 构造方法： public Thread()：分配一个新的线程对象。 public Thread(String name)：分配一个指定名字的新的线程对象。 public Thread(Runable target)：分配一个带有制定目标新的线程对象。 public Thread(Runable target,String name)：分配一个带有指定目标新的线程对象并指定名字。 常用方法： 1.public Str
Thread线程知识点讲解
CRMEB小程序商城的博客
03-31 1098
内部属性 //线程名，如果创建时没有指定则使用Thread- + 创建序列号 private volatile String name; //线程优先级 Java只是给操作系统一个优先级的参考值，线程最终在操作系统的优先级是多少还是由操作系统决定。 private int priority; //守护线程 private boolean daemon = false; //为JVM保留字段 private boolean stillborn = false;
Thread-----------多线程1
qq_40378121的博客
04-25 227
多线程1 我们在之前，学习的程序在没有跳转语句的前提下，都是由上至下依次执行，那现在想要设计一个程序，边打游戏边听歌，怎么设计？ 要解决上述问题,咱们得使用多进程或者多线程来解决. 1.1 并发与并行 并行：指两个或多个事件在同一时刻发生（同时执行）。 并发：指两个或多个事件在同一个时间段内发生(交替执行)。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YXX...
【Java并发编程】深入分析Thread(七)
程序员小毛驴的博客
01-28 6188
一、线程    1.1什么是线程？     线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值