package com.atguigu.java_thread;
/*
* 创建一个子线程，完成1-100之间自然数的输出。同样地，主线程执行同样的操作
* 创建多线程的第一种方式：继承java.lang.Thread类
*
*/
//1.创建一个继承与Thread的类
class SubThread extends Thread {
// 2.重写Thread类的run()方法.方法内实现此子线程要完成的功能
public void run() {
for (int i = 1; i <= 100; i++) {
System.out.println(Thread.currentThread().getName() +":"+ i);
}
}
}
public class TestThread {
public static void main(String[] args) {
//3.创建一个子类的对象
SubThread st = new SubThread();
SubThread st2 = new SubThread();
//4.调用线程的start()：启动此线程：调用相应的run()方法
//一个线程只能够执行一次start()
//不能通过Thread实现类对象的run()去启动一个线程
st.start();
st2.start();
//st.start();
//st.run();
for (int i = 1; i <= 100; i++) {
System.out.println(Thread.currentThread().getName() +":"+ i);
}
}
}
package com.atguigu.java_thread;
/*
* Thread的常用方法
* 1.start():启动线程并执行相应的run()方法
* 2.run()：子线程要执行的代码放入run()方法中
* 3.currenThread():静态的，调取当前的线程
* 4.getName():获取此线程的名字
* 5.setName():设置此线程的名字
* 6.yield():调用此方法的线程释放当前CPU的执行权
* 7.join():在A线程中调用B线程的join()方法，表示:当执行到此方法，A线程停止执行，直到B线程执行完毕
* 8.isAlive():判断此线程是否存活
* 9.sleep(long l):显示的让当前线程睡眠l毫秒
* 10.线程通信：wait() notify() notifyAll()
*
* 设置线程的优先级
* getPriority() ：返回线程优先值
* setPriority(int newPriority) ：改变线程的优先级
* 线程创建时继承父线程的优先级
*
*/
//1.创建一个继承与Thread的类
class SubThread1 extends Thread {
// 2.重写Thread类的run()方法.方法内实现此子线程要完成的功能
public void run() {
for (int i = 1; i <= 100; i++) {
// try {
// Thread.currentThread().sleep(1000);
// } catch (InterruptedException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i);
}
}
}
public class TestThread1 {
public static void main(String[] args) {
SubThread1 st1 = new SubThread1();
st1.setName("子线程1");
st1.setPriority(Thread.MAX_PRIORITY);
st1.start();
Thread.currentThread().setName("--------主线程");
for (int i = 1; i <= 100; i++) {
System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i);
// if(i % 10 == 0){
// Thread.currentThread().yield();
// }
// if(i == 20){
// try {
// st1.join();
// } catch (InterruptedException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// }
// System.out.println(st1.isAlive());
}
}
}
package com.atguigu.java_thread;
/*
* 创建多线程的方式二：通过实现的方式
*
* 对比继承的方式 VS实现的方式
* 1.联系：public class Thread implements Runnable
* 2.哪个方式好？实现的方式优于继承的方式
* >实现的方式避免了java单继承的局限性
* >如果多个线程要操作同一份资源（数据），更适合使用实现的方式
*
*/
//1.创建一个实现了Runnable接口的类
class Print implements Runnable{
//2.实现接口的抽象方法
public void run() {
//子线程执行的代码
for (int i = 1; i <= 100; i++) {
System.out.println(Thread.currentThread().getName() +":"+ i);
}
}
}
public class TestThread2 {
public static void main(String[] args) {
//3.创建一个Runnable接口实现类的对象
Print p = new Print();
//p.start();
//p.run();
//要想启动多线程必须调用start()方法
//4.将此对象作为形参传递给Thread类的构造器中，创建Thread类的对象，此对象即为一个线程
Thread t1 = new Thread(p);
//5.调用start()方法：启动线程并执行run()方法
t1.start();//启动线程：执行Thread对象生成时构造器形参的构造方法
//再创建一个线程
Thread t2 = new Thread(p);
t2.start();
}
}
package com.atguigu.java_thread;
//模拟火车站售票窗口，开启三个窗口售票，总票数为100张
//存在线程的安全问题
class WindowThread extends Thread{
static int ticket = 100;//申明成静态类变量，三个对象共用
public void run(){
while(true){
if(ticket > 0){
System.out.println(Thread.currentThread().getName() +"售票,票号为：" + ticket--);
}else{
break;
}
}
}
}
public class TestWindow {
public static void main(String[] args) {
WindowThread w1 = new WindowThread();
WindowThread w2 = new WindowThread();
WindowThread w3 = new WindowThread();
w1.setName("窗口一");
w2.setName("窗口二");
w3.setName("窗口三");
w1.start();
w2.start();
w3.start();
}
}
package com.atguigu.java_thread;
//使用实现Runnable接口的方式，售票
class WindowThread1 extends Thread {
int ticket = 100;// 共享数据
public void run() {
while (true) {
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--);
} else {
break;
}
}
}
}
public class TestWindow1 {
public static void main(String[] args) {
WindowThread2 w = new WindowThread2();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}
package com.atguigu.java_thread;
//使用实现Runnable接口的方式，售票
/*
* 此程序存在线程的安全问题：打印车票时会出现重票、错票
* 1.线程安全问题存在的原因？
* 由于一个线程在操作共享数据过程中，未执行完毕的情况下，另外的线程参与进来，
* 导致共享数据出现的安全问题
*
* 2.如何解决线程的安全问题？
* 必须让一个线程操作共享数据完毕以后，其它线程才有机会参与共享数据的操作。
*
* 3.java如何实现线程的安全：线程的同步机制
*
* 方式一：同步代码块
* synchronized(同步监视器){
* //需要被同步的代码块(即为操作共享数据的代码)
* }
* 1.共享数据：多个线程共同操作的同一个数据(变量)
* 2.同步监视器：由任何一个类的对象来充当。哪个线程获取此监视器，谁就能操作大括号里被同步的代码，俗称：锁
* 要求：所有的线程必须共用同一把锁！
* 注：在实现的方式中，考虑同步的话，可以使用this来充当锁，
* 但是在继承的方式中慎用this
*
* 方式二：同步方法
*
*
*/
class WindowThread2 extends Thread{
int ticket = 100;//共享数据
//Object obj = new Object();
public void run(){
//Animal a = new Animal();//局部变量
while(true){
// synchronized (obj) {
synchronized (this) {//this表示当前对象，本题中表示w
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--);
}else{
break;
}
}
}
}
}
public class TestWindow2 {
public static void main(String[] args) {
WindowThread2 w = new WindowThread2();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}
package com.atguigu.java_thread;
//模拟火车站售票窗口，开启三个窗口售票，总票数为100张
//存在线程的安全问题
class WindowThread3 extends Thread{
static int ticket = 100;//申明成静态类变量，三个对象共用
static Object obj = new Object();
public void run(){
while(true){
//synchronized (this) {//本题中this表示：w1 w2 w3
synchronized (obj) {
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--);
}else{
break;
}
}
}
}
}
public class TestWindow3 {
public static void main(String[] args) {
WindowThread3 w1 = new WindowThread3();
WindowThread3 w2 = new WindowThread3();
WindowThread3 w3 = new WindowThread3();
w1.setName("窗口一");
w2.setName("窗口二");
w3.setName("窗口三");
w1.start();
w2.start();
w3.start();
}
}
package com.atguigu.java_thread;
//使用实现Runnable接口的方式，售票
/*
* 此程序存在线程的安全问题：打印车票时会出现重票、错票
* 1.线程安全问题存在的原因？
* 由于一个线程在操作共享数据过程中，未执行完毕的情况下，另外的线程参与进来，
* 导致共享数据出现的安全问题
*
* 2.如何解决线程的安全问题？
* 必须让一个线程操作共享数据完毕以后，其它线程才有机会参与共享数据的操作。
*
* 3.java如何实现线程的安全：线程的同步机制
*
* 方式一：同步代码块
* synchronized(同步监视器){
* //需要被同步的代码块(即为操作共享数据的代码)
* }
* 1.共享数据：多个线程共同操作的同一个数据(变量)
* 2.同步监视器：由任何一个类的对象来充当。哪个线程获取此监视器，谁就能操作大括号里被同步的代码，俗称：锁
* 要求：所有的线程必须共用同一把锁！
* 注：在实现的方式中，考虑同步的话，可以使用this来充当锁，
* 但是在继承的方式中慎用this
*
* 方式二：同步方法
* 将操作共享数据的方法声明为synchronized。即此方法为同步方法，能够保证当其中一个线程
* 执行此方法时，其它线程在外等待直至此线程执行完此方法。
*
* 4.线程的同步的弊端：由于同一个时间内只能有一个线程访问共享数据，效率变低了。
*/
class WindowThread4 extends Thread{
int ticket = 100;//共享数据
public void run(){
while(true){
show();
}
}
public synchronized void show() {
// synchronized (this) {// this表示当前对象，本题中表示w
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) {
WindowThread4 w = new WindowThread4();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}
package com.atguigu.java_thread;
//线程通信:如下三个关键字使用的话，都得在同步代码块或同步方法中。
//wait():一旦一个i额线程执行到wait()，就释放当前的锁。
//notify() notifyAll()：唤醒wait的一个或所有的线程
//使用两个线程打印1-100，线程1，线程2交替打印
class PrintNum implements Runnable {
int num = 1;
@Override
public void run() {
while (true) {
synchronized (this) {
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 {
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();
}
}
相关推荐
java 线程相关工具类.java 线程相关工具类.java 线程相关工具类.java 线程相关工具类.java 线程相关工具类.java 线程相关工具类.java 线程相关工具类.java 线程相关工具类.java 线程相关工具类.java 线程相关工具类....
电子书相关：包含4个有关JAVA线程的电子书（几乎涵盖全部有关线程的书籍） OReilly.Java.Threads.3rd.Edition.Sep.2004.eBook-DDU Java Thread Programming (Sams) java线程第二版中英文 java线程第二版中英文 ...
本主题将深入探讨Java线程的相关知识点，包括线程的创建、状态、调度、对象锁以及线程组。 首先，让我们从11.1章节的“线程与线程类”开始。在Java中，线程有两种主要的创建方式：继承`Thread`类或实现`Runnable`...
java 线程工具类 java 线程工具类java 线程工具类 java 线程工具类java 线程工具类 java 线程工具类java 线程工具类 java 线程工具类java 线程工具类 java 线程工具类java 线程工具类 java 线程工具类java 线程工具...
根据提供的信息，我们可以推断出这份文档主要关注的是Java线程的相关内容。下面将围绕“Java线程”这一主题展开详细的介绍与解释。 ### Java线程基础 在Java语言中，线程是程序执行流的基本单元。一个标准的Java...
Java线程状态流转图中，以下方法与线程状态转换相关： * Object.wait()：使线程从RUNNABLE状态转换到WAITING状态。 * Object.notify()：使线程从WAITING状态转换到RUNNABLE状态。 * Object.notifyAll()：使多个线程...
本书浅显易懂的介绍了JAVA线程相关的设计模式，通过程序范例和UML图示来一一解说，书中代码的重要部分加了标注以使读者更加容易理解，再加上图文并茂，对于初学者还是程序设计高手来说，这都是一本学习和认识JAVA...
本文将深入探讨Java线程的概念、生命周期、实现方式以及相关的同步机制。 首先，理解线程的基本概念至关重要。线程是程序中一个单一的顺序控制流，它在程序的上下文中运行，但具有独立的执行路径。多线程则是指在...
Java多线程机制是Java编程中至关重要的一部分，它允许程序同时执行多个任务，提升应用程序的效率和响应性。以下是对各个知识点的详细说明： 9.1 Java中的线程： Java程序中的线程是在操作系统级别的线程基础上进行...
java 线程Dump 分析工具： Java的TDA线程转储分析器是一个用于分析Sun Java VM生成的线程转储和堆信息的小型Swing GUI(目前用1.4测试)。它从提供的日志文件中解析线程转储和类直方图。它提供关于发现的线程转储的...
Java线程分析是Java开发中的重要环节，尤其是在处理性能优化、死锁排查或者并发问题时。TDA（Thread Dump Analyzer）是一款强大的Java线程分析工具，它能够帮助开发者深入理解应用在运行时的线程状态，包括线程的...
Java线程是Java编程中的重要概念，特别是在多核处理器和并发处理中不可或缺。Java线程允许程序在同一时间执行多个不同的任务，从而提高了程序的效率和响应性。在燕山大学信息学院计算机系的课程中，李峰教授讲解了...
《Java线程(第三版)》是一本深入探讨Java线程技术的专业书籍，旨在帮助开发者理解和掌握Java平台上的多线程编程。Java线程是并发编程的重要组成部分，它允许程序同时执行多个任务，从而充分利用系统资源，提高程序的...
Java线程有10个优先级（MIN_PRIORITY, NORM_PRIORITY, MAX_PRIORITY），默认优先级是NORM_PRIORITY。但是，线程优先级并不保证绝对的执行顺序，操作系统调度策略可能影响实际执行顺序。 7. join()方法： 一个线程...
本文将深入解析Java线程的相关知识点，包括线程的定义、创建、状态管理、线程同步和安全问题。 1. **线程定义** 在Java中，线程是进程中的单一顺序控制流，是程序执行的基本单元。线程在进程的上下文中运行，共享...
JAVA线程dump的分析 JAVA线程dump是指在JAVA程序中，当前线程的状态和调用堆栈的快照，能够帮助开发者了解当前程序的执行情况，诊断问题和性能瓶颈。生成JAVA线程dump的方法在不同的操作系统下是不同的，在Windows...
Java线程是Java编程语言中的一个核心概念，它允许程序同时执行多个任务，极大地提高了程序的并发性和效率。本教程将深入探讨Java线程的使用，帮助开发者掌握这一关键技术。 一、线程基础 1. **线程的概念**：线程...
Java线程是多任务编程的重要概念，它允许程序同时执行多个独立的任务，从而提高系统效率和响应速度。在Java中，线程可以分为用户线程和守护线程，前者是程序运行的基础，而后者是在所有用户线程结束时才终止的后台...
### JAVA中的单线程与多线程概念解析 #### 单线程的理解 在Java编程环境中，单线程指的是程序执行过程中只有一个线程在运行。这意味着任何时刻只能执行一个任务，上一个任务完成后才会进行下一个任务。单线程模型...
本资源"JAVA线程学习(源代码)"提供了关于Java线程的源代码示例，帮助我们深入理解和实践线程的使用。 首先，我们要理解Java中的线程模型。Java线程由`java.lang.Thread`类或`java.util.concurrent.Executor`框架来...