JAVA基础day17

最新推荐文章于 2021-07-26 19:07:30 发布
最新推荐文章于 2021-07-26 19:07:30 发布
阅读量88 收藏
点赞数
分类专栏： JAVA基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/penghui_/article/details/103827011
版权

package com.atguigu.exer;
/*

  • 银行有一个账户。
    有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打印账户余额。

1.是否涉及到多线程？是！有两个储户(两种方式创建多线程)
2.是否有共享数据？有！同一个账户
3.得考虑线程的同步。（两种方法处理线程的安全）

//拓展：实现二者交替打印。使用线程的通信
*/
class Account{
double balance;//余额
public Account(){

}
//存钱
public synchronized void deposit(double amt){
	notify();
	balance += amt;
	try {
		Thread.currentThread().sleep(10);
	} catch (InterruptedException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	System.out.println(Thread.currentThread().getName() + ":" + balance);
	try {
		wait();
	} catch (InterruptedException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}

}
class Customer extends Thread{
Account account;

public Customer(Account account){
	this.account = account;
}

public void run(){
	for(int i = 0;i < 3;i++){
		account.deposit(1000);
	}
}

}

public class TestAccount {
public static void main(String[] args) {
Account acct = new Account();
Customer c1 = new Customer(acct);
Customer c2 = new Customer(acct);

	c1.setName("甲");
	c2.setName("乙");
	
	c1.start();
	c2.start();
}

}

package com.atguigu.java;
//创建多线程的方式一：继承于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();
}
}

package com.atguigu.java;

/*

  • 创建多线程的方式二：通过实现的方式
  • 对比一下继承的方式 vs 实现的方式
  • 1.联系：public class Thread implements Runnable
  • 2.哪个方式好？实现的方式优于继承的方式
  • why? ① 避免了java单继承的局限性
  •  	② 如果多个线程要操作同一份资源(或数据)，更适合使用实现的方式

*/
//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§;
//5.调用start()方法：启动线程并执行run()
t1.start();//启动线程；执行Thread对象生成时构造器形参的对象的run()方法。

	//再创建一个线程
	Thread t2 = new Thread(p);
	t2.start();
}

}

package com.atguigu.java;

//模拟火车站售票窗口，开启三个窗口售票，总票数为100张
//存在线程的安全问题
class Window 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) {
Window w1 = new Window();
Window w2 = new Window();
Window w3 = new Window();

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

}

package com.atguigu.java;

//使用实现Runnable接口的方式，售票
/*

  • 此程序存在线程的安全问题：打印车票时，会出现重票、错票
    */

class Window1 implements Runnable {
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) {
Window1 w = new Window1();
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();
}

}

package com.atguigu.java;

//使用实现Runnable接口的方式，售票
/*

  • 此程序存在线程的安全问题：打印车票时，会出现重票、错票
  • 1.线程安全问题存在的原因？
  • 由于一个线程在操作共享数据过程中，未执行完毕的情况下，另外的线程参与进来，导致共享数据存在了安全问题。
  • 2.如何来解决线程的安全问题？
  • 必须让一个线程操作共享数据完毕以后，其它线程才有机会参与共享数据的操作。
  • 3.java如何实现线程的安全：线程的同步机制
  •  方式一：同步代码块

  •  synchronized(同步监视器){

  •  	//需要被同步的代码块（即为操作共享数据的代码）

  •  }

  •  1.共享数据：多个线程共同操作的同一个数据(变量)

  •  2.同步监视器：由一个类的对象来充当。哪个线程获取此监视器，谁就执行大括号里被同步的代码。俗称：锁

  •  要求：所有的线程必须共用同一把锁！

  •  注：在实现的方式中，考虑同步的话，可以使用this来充当锁。但是在继承的方式中，慎用this!

  •  方式二：同步方法

*/

class Window2 implements Runnable {
int ticket = 100;// 共享数据
// Object obj = new Object();
public void run() {
// Animal a = new Animal();//局部变量
while (true) {
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 TestWindow2 {
public static void main(String[] args) {
Window2 w = new Window2();
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();
}

}
class Animal{

}

package com.atguigu.java;

//模拟火车站售票窗口，开启三个窗口售票，总票数为100张
//存在线程的安全问题—>使用同步代码块处理。
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();

}

}

package com.atguigu.java;

//使用实现Runnable接口的方式，售票
/*

  • 此程序存在线程的安全问题：打印车票时，会出现重票、错票
  • 1.线程安全问题存在的原因？
  • 由于一个线程在操作共享数据过程中，未执行完毕的情况下，另外的线程参与进来，导致共享数据存在了安全问题。
  • 2.如何来解决线程的安全问题？
  • 必须让一个线程操作共享数据完毕以后，其它线程才有机会参与共享数据的操作。
  • 3.java如何实现线程的安全：线程的同步机制
  •  方式一：同步代码块

  •  synchronized(同步监视器){

  •  	//需要被同步的代码块（即为操作共享数据的代码）

  •  }

  •  1.共享数据：多个线程共同操作的同一个数据(变量)

  •  2.同步监视器：由一个类的对象来充当。哪个线程获取此监视器，谁就执行大括号里被同步的代码。俗称：锁

  •  要求：所有的线程必须共用同一把锁！

  •  注：在实现的方式中，考虑同步的话，可以使用this来充当锁。但是在继承的方式中，慎用this!

  •  方式二：同步方法

  •  将操作共享数据的方法声明为synchronized。即此方法为同步方法，能够保证当其中一个线程执行

  •  此方法时，其它线程在外等待直至此线程执行完此方法。

  •  >同步方法的锁：this
  • 4.线程的同步的弊端：由于同一个时间只能有一个线程访问共享数据，效率变低了。

*/

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();
}

}

package com.atguigu.java1;

class A {
public synchronized void foo(B b) {//锁：A的对象a
try {
Thread.currentThread().sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
b.last();
}

public synchronized void last() {//锁：A的对象a
}

}

class B {
public synchronized void bar(A a) {//锁：B的对象 b
try {
Thread.currentThread().sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
a.last();
}

public synchronized void last() {//锁：B的对象 b
	
}

}

public class DeadLock implements Runnable {
A a = new A();
B b = new B();

public void init() {
	a.foo(b);
}

public void run() {
	b.bar(a);
}

public static void main(String[] args) {
	DeadLock dl = new DeadLock();
	new Thread(dl).start();
	dl.init();
}

}

package com.atguigu.java1;

//线程通信。如下的三个关键字使用的话，都得在同步代码块或同步方法中。
//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§;
Thread t2 = new Thread§;

	t1.setName("甲");
	t2.setName("乙");
	
	t1.start();
	t2.start();
}

}

package com.atguigu.java1;

//死锁的问题：处理线程同步时容易出现。
//不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
//写代码时，要避免死锁！
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 (InterruptedException 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 (InterruptedException 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();
}

}

package com.atguigu.java1;
/*

  • 生产者/消费者问题

  • 生产者(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(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		clerk.addProduct();
		
	}
}

}
class Consumer implements Runnable{//消费者
Clerk clerk;
public Consumer(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.consumeProduct();
}
}
}

public class TestProduceConsume {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Producer p1 = new Producer(clerk);
Consumer c1 = new Consumer(clerk);
Thread t1 = new Thread(p1);//一个生产者的线程
Thread t3 = new Thread(p1);
Thread t2 = new Thread(c1);//一个消费者的线程

	t1.setName("生产者1");
	t2.setName("消费者1");
	t3.setName("生产者2");
	
	t1.start();
	t2.start();
	t3.start();
}

}

package com.atguigu.java1;

//关于懒汉式的线程安全问题：使用同步机制
//对于一般的方法内，使用同步代码块，可以考虑使用this。
//对于静态方法而言，使用当前类本身充当锁。
class Singleton {
private Singleton() {

}

private static Singleton instance = null;

public static Singleton getInstance() {
	
	if (instance == null) {
		synchronized (Singleton.class) {
			if (instance == null) {

				instance = new Singleton();
			}
		}
	}
	return instance;
}

}

public class TestSingleton {

public static void main(String[] args) {
	Singleton s1 = Singleton.getInstance();
	Singleton s2 = Singleton.getInstance();
	System.out.println(s1 == s2);
	// Class clazz = Singleton.class;
}

}

penghui_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java基础day01
03-25
### Java基础Day01知识点详解 #### Java基础知识 1. **计算机基础知识** - **计算机定义**：全称为Computer，俗称电脑，是一种能够按照程序运行，自动、高速处理海量数据的现代化智能电子设备。它由硬件和软件两...
Java基础day01
07-20
Java是一种广泛应用于各种领域的编程语言，尤其在企业级应用开发中占据着主导地位...从第一天的Java基础学习开始，随着对语言特性的理解和实践，开发者可以逐步构建起坚实的技术基础，从而在各种领域中发挥Java的优势。
Java基础day03(ppt文档).pptx
最新发布
11-13
Java基础day03（ppt文档） 本章节主要介绍了Java语言的基本语法，包括数据类型的转换、运算符的介绍、运算符的优先级、语句的介绍等内容。 1. 数据类型的转换 Java中可以进行不同数据类型的加减乘除运算吗？答案...
Java基础Day05.xmind
06-29
适合java初学者
JAVA基础day14
penghui_的博客
01-03 1462
package com.atguigu.exer; /* 定义一个Employee类， 该类包含：private成员变量name,age,birthday，其中 birthday 为 MyDate 类的对象； 并为每一个属性定义 getter, setter 方法； 并重写 toString 方法输出 name, age, birthday */ public class Employee i...
JAVA基础day05
penghui_的博客
01-03 814
package com.atguigu.exer; //利用面向对象的编程方法，设计类Circle计算圆的面积。 public class TestCircle { public static void main(String[] args) { Circle c1 = new Circle(); c1.radius = 2.3; //c1.findArea(); double area = c1...
JAVA基础day11
penghui_的博客
01-03 524
package com.atguigu.exer; /* 定义一个Employee类，该类包含： private成员变量name,number,birthday，其中birthday 为MyDate类的对象； abstract方法earnings()；toString()方法输出对象的name,number和birthday。 */ public abstract class Employee...
JAVA基础day12
penghui_的博客
01-03 480
package src.com.atguigu.exer; /* 编写应用程序EcmDef.java，接收命令行的两个参数，要求不能输入负数，计算两数相除。 对数据类型不一致(NumberFormatException)、缺少命令行参数(ArrayIndexOutOfBoundsException、 除0(ArithmeticException)及输入负数(EcDef 自定义的异常)进行异常处理...
JAVA基础day10
penghui_的博客
01-03 369
package com.atguigu.exer; public class Circle extends GeometricObject{ private double radius; public double getRadius() { return radius; } public void setRadius(double radius) { this.radius = radiu...
JAVA基础day06
penghui_的博客
01-03 347
package com.atguigu.exer; /* （1）定义一个Circle类，包含一个double型的radius属性代表圆的半径， 一个findArea()方法返回圆的面积。 （2）定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义如下： public void printAreas(Cirlce c, int time) 在printAreas...
JAVA基础day08
penghui_的博客
01-03 342
package com.atguigu.exer; public class Account { protected int id;//账号 protected double balance;//余额 protected double annualInterestRate;//年利率 public Account(int id, double balance, double annualInter...
JAVA基础day07
penghui_的博客
01-03 310
package com.atguigu.exer; public class Account { private int id;//账号 private double balance;//余额 private double annualInterestRate;//年利率 public Account(int id, double balance, double annualInterestRat...
JAVA基础day13
penghui_的博客
01-03 279
package src.com.atguigu.exer; /* 定义一个Employee类， 该类包含：private成员变量name,age,birthday，其中 birthday 为 MyDate 类的对象； 并为每一个属性定义 getter, setter 方法； 并重写 toString 方法输出 name, age, birthday */ public class Employ...
JAVA基础day04
penghui_的博客
01-03 274
package com.atguigu.exer; /* (1)创建一个名为TestArray的类，在main()方法中声明array1和array2两个变量， 他们是int[]类型的数组。 (2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。 (3)显示array1的内容。 (4)赋值array2变量等于array1，修改array2中的偶索引元素，使...
collection-泛型
penghui_的博客
07-26 271
day02【Collection、泛型】 主要内容 Collection集合 迭代器 增强for 泛型 教学目标 能够说出集合与数组的区别 说出Collection集合的常用功能 能够使用迭代器对集合进行取元素 能够说出集合的使用细节 能够使用集合存储自定义类型 能够使用foreach循环遍历集合 能够使用泛型定义集合对象 能够理解泛型上下限 能够阐述泛型通配符的作用 第一章 Collection集合 1.1 集合概述 在前面基础班我们已经学习过并使用过集合ArrayList ,那
JAVA基础day16
penghui_的博客
01-03 163
package com.atguigu.exer; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; /* Create a program named MyInput.java: Contain the methods for reading int, dou...
JAVA基础day09
penghui_的博客
01-03 137
package com.atguigu.exer; public class Circle extends GeometricObject{ private double radius; public Circle(){ // this.color = “white”; // this.weight = 1.0; this.radius = 1.0; } public Circle(doub...
JAVA基础day01
penghui_的博客
01-03 134
package day01; //测试算术运算符： + - + - * / % ++ – + class TestAri{ public static void main(String[] args){ // 除：/ int i = 12; int j = i/5; double d = i / 5; double d1 = i/5.0; System.out.println(j);//2 Sys...
Java基础入门：Day1-3课程精华概览
- Day01: 开始时会介绍Java的起源和发展历程，帮助学生理解Java作为一门广泛使用的编程语言的原因。 - **Java语言特性**：深入探讨Java的特性，如平台无关性、垃圾回收机制和强类型系统，这些将影响开发者编写可...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值