package day_01;
/**
多线程
程序 : 一组命令的集合,为了完成指定的功能,程序是静态概念,一般保存在硬盘当中
进程 : 正在运行的程序,是一个动态概念,需要保存在内存当中,操作系统会生成对应的pid,
需要CPU时间链来执行,当我们直接关闭某个进程的时候,该进程会在运行内存中被销毁
线程 : 进程可以进一步细化为线程,一个程序中,不同的执行分支,如果同一个时间节点,
允许多个线程同时执行的时候,我们称为支持多线程
在java中,main方法开始执行,就是一个线程,称为主线程
并行 : 多个CPU,同时执行多个任务
并发 : 一个CPU,同时执行多个任务
多线程并行,必须CPU大于等于2才行
单核CPU没有多线程
*
* @author SEC90
* @Date 2022年1月24日上午9:25:35
*/
public class Thread_01_Create {
public static void main(String[] args) {
// test_01();
test_02();
} public static void test_02() {
// 创建实现类对象
Processor_01 p = new Processor_01();
// 创建线程类对象
Thread t1 = new Thread(p);
// 启动线程
t1.start();
for (int i = 0; i < 10; i++) {
System.out.println("main线程-->" + i);
}
} public static void test_01() {
// 创建线程类对象
Thread t1 = new Processor();
// 调用start方法 启动线程
t1.start();
for (int i = 0; i < 10; i++) {
System.out.println("main线程-->" + i);
}
}
}/**
* 第一种 创建一个类,继承Thread类 并覆写run方法
*
* run方法 就等于是新线程中的main方法
*
* @author 天亮教育-帅气多汁你泽哥
* @Date 2022年1月24日 上午10:25:31
*/
class Processor extends Thread {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("测试线程-->" + i);
}
}
}/**
* 第二种 创建一个类,实现Runnable接口,并覆写run方法
*
* run方法 就等于是新线程中的main方法
*
* @author 天亮教育-帅气多汁你泽哥
* @Date 2022年1月24日 上午10:30:40
*/
class Processor_01 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("测试线程-->" + i);
}
}
}package day_01;
/**
* getName : 获取线程的名字
*
* setName : 设置线程的名字,如果不设置,默认是Thread-0开始 依次递增
*
* setPriority() : 设置优先级,java中有1-10 ,10个优先级等级
* MIN_PRIORITY = 1
* NORM_PRIORITY = 5
* MAX_PRIORITY = 10
*
* getPriority() : 获取优先级等级
*
* static currentThread() : 获取当前线程对象
*
* static sleep() : 让当前线程进入睡眠状态
*
* currentThread和sleep 是静态方法,意味着 和哪个对象调用无关
*
* currentThread : 出现在哪个线程中,就获取哪个线程的对象
* sleep : 出现在哪个线程中,就睡眠哪个线程,参数为long类型的毫秒数
*
* @author SEC90
* @Date 2022年1月24日 上午10:41:02
*/
public class Thread_02_Priority {
public static void main(String[] args) {
// 创建线程对象
Thread t1 = new Processer();
// 设置名字
t1.setName("t1");
// 设置优先级为10
t1.setPriority(10);
// 设置main的优先级为1
Thread.currentThread().setPriority(1);
// 启动线程
t1.start();
for (int i = 0; i < 10; i++) {
try {
// 睡眠500毫秒
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 获取线程对象并获取线程名字
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
}class Processer extends Thread {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
}package day_01;
/**
* stop : 终止否个线程执行,该方法已过时,不推荐使用,因为有可能导致死锁
*
* 所以一般使用标识符解决
*
* @author SEC90
* @Date 2022年1月24日 上午11:06:05
*/
public class Thread_03_Stop {
public static void main(String[] args) {
Processer_03 p = new Processer_03();
Thread t1 = new Thread(p);
t1.setName("t1");
t1.start(); try {
Thread.sleep(5000);
// t1.stop();
p.flag=true;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}class Processer_03 implements Runnable {
// 加一个标识,标识是否要终止线程
boolean flag = false; @Override
public void run() {
for (int i = 0; true; i++) {
// 判断是否要终止
if (flag) {
System.out.println(Thread.currentThread().getName() + "线程已被终止");
return;
}
try {
Thread.sleep(1000);
System.out
.println(Thread.currentThread().getName() + "-->" + i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}package day_01;
/**
* join : 线程合并,让当前线程等待指定线程执行完,再继续执行
*
* @author SEC90
* @Date 2022年1月24日 下午2:03:29
*/
public class Thread_04_Join {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Processer_04();
t1.setName("t1");
t1.start();
// 到这里,main就要等着t1线程执行完之后,再继续执行
t1.join();
for (int i = 0; i < 10; i++) {
try {
// 睡眠500毫秒
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 获取线程对象并获取线程名字
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}class Processer_04 extends Thread {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
// 睡眠500毫秒
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 获取线程对象并获取线程名字
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}package day_01;
/**
* yield : 静态方法,暂停当前正在执行的线程对象,并执行其他等待中的线程
*
* 1 静态方法,意味着跟那个对象调用没有官谢,写在哪个线程中,哪个线程就让位
*
* 2 给同优先级让位,不同优先级不让位
*
* @author SEC90
* @Date 2022年1月24日 下午2:07:39
*/
public class Thread_05_Yield {
public static void main(String[] args) {
// 创建线程
Thread t1 = new Thread(new Processor_05());
t1.setName("t1");
// 设置t1线程和main线程优先级一致
t1.setPriority(5);
Thread.currentThread().setPriority(5);
// 启动
t1.start();
for (int i = 0; i < 10; i++) {
// 让位
Thread.yield();
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
}
class Processor_05 implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
}package day_01;
/**
* 线程同步 : 当多个线程有可能同时操作同一个数据的时候,为了保证数据一致性,需要进行同步执行
*
* 本质是同步数据,是一种安全机制
*
* 异步编程 : 线程之间是完全独立的,相互没有影响
*
* 同步编程 : 线程之间不是完全独立的,相互可能有影响
*
* 同步的场景 : 1 必须是多线程(必须有并发性,才有可能出错) 2 多个线程有可能在同一时间操作同一个数据的可能性 3
* 尤其是同时对数据进行更改操作,查询无所谓
*
* @author SEC90
* @Date 2022年1月24日 下午2:25:36
*/
public class Thread_06_Synchroinzation {
public static void main(String[] args) {
// 创建账户,余额为3000
Account act = new Account(3000);
// 两个线程,每个取1000
Thread t1 = new Processor_06(act);
Thread t2 = new Processor_06(act);
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
}
}// 线程类
class Processor_06 extends Thread {
// 账户
Account act;
public Processor_06(Account act) {
this.act = act;
} @Override
public void run() {
// 取1000
act.withDraw(1000);
}
}// 实体类
class Account {
// 余额
private double balance;// public synchronized void withDraw(double money) {
public void withDraw(double money) {
// 如果该方法加了synchronized,那么该方法就只能有一个线程执行
System.out.println(Thread.currentThread().getName() + " 执行了");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 语句块锁
synchronized (this) {
// 余额减去取钱金额
double after = balance - money;
// 新余额复制给余额
balance = after; // 2000
System.out.println(Thread.currentThread().getName() + " 取钱成功,取款 : "
+ money + "元,剩余 : " + balance + " 元 ");
}
} public Account(double balance) {
super();
this.balance = balance;
} public Account() {
super();
} public double getBalance() {
return balance;
} public void setBalance(double balance) {
this.balance = balance;
}}
package day_01;
/**
* synchronized(对象){} 成员语句块锁
*
* 当访问一个对象中加锁的成员方法或者成员成员语句块锁的时候,则该对象中所有加锁的成员方法和成员语句块锁 全部锁定
*
* synchronized(类名.class){} 静态语句块锁
*
* 当访问一个类中,加锁的静态方法或者静态语句块锁的时候,则该对象中所有加锁的静态方法和静态语句块锁 全部锁定
*
* @author SEC90
* @Date 2022年1月24日 下午3:23:53
*/
public class Thread_07_Synchroinzation {
public static void main(String[] args) {
MyClass_01 mc = new MyClass_01();
Thread t1 = new Thread(new Processor_08(mc));
Thread t2 = new Thread(new Processor_08(mc));
Thread t3 = new Thread(new Processor_08(mc));
t1.setName("t1");
t2.setName("t2");
t3.setName("t3");
t1.start();
// 保证t1先执行,进入m1方法执行睡眠
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
t2.start();
t3.start();
// 1秒后 m3执行,3秒后 m1和m2执行
}
}class Processor_08 implements Runnable {
MyClass_01 mc; public Processor_08(MyClass_01 mc) {
this.mc = mc;
} @Override
public void run() {
// 获取线程名字
String name = Thread.currentThread().getName();
if (name.equals("t1")) {
mc.m1();
} else if (name.equals("t2")) {
mc.m2();
}
if (name.equals("t3")) {
mc.m3();
}
}
}// 业务类
class MyClass_01 {
public synchronized void m1() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("加锁的m1方法");
} public synchronized void m2() {
System.out.println("加锁的m2方法");
} public void m3() {
System.out.println("未加锁的m3方法");
}
}package day_01;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;/**
* lock 是显示锁,需要手动开启和关闭 synchronized是隐式锁,自动开启,执行完自动关闭
*
* lock只有代码块锁 , 而 synchronized支持方法和代码块锁
*
* lock锁,需要JVM花费较少的时间来进行资源调度.性能相对较好,而有很好的扩展性
*
* 使用顺序 : Lock锁 ---> 同步代码块锁 ---> 方法锁
*
* @author SEC90
* @Date 2022年1月24日 下午2:25:36
*/
public class Thread_08_Lock {
public static void main(String[] args) {
// 创建账户,余额为3000
Account1 act = new Account1(3000);
// 两个线程,每个取1000
Thread t1 = new Processor_09(act);
Thread t2 = new Processor_09(act);
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
}
}// 线程类
class Processor_09 extends Thread {
// 账户
Account1 act; public Processor_09(Account1 act) {
this.act = act;
} @Override
public void run() {
// 取1000
act.withDraw(1000);
}
}// 实体类
class Account1 {
// 余额
private double balance; // 创建锁对象
Lock lock = new ReentrantLock();
public void withDraw(double money) {
System.out.println(Thread.currentThread().getName()+" 进来了");
// 开始同步
lock.lock();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 语句块锁
// 余额减去取钱金额
double after = balance - money;
// 新余额复制给余额
balance = after; // 2000
System.out.println(Thread.currentThread().getName() + " 取钱成功,取款 : "
+ money + "元,剩余 : " + balance + " 元 ");
// 解锁
lock.unlock();
} public Account1(double balance) {
super();
this.balance = balance;
} public Account1() {
super();
} public double getBalance() {
return balance;
} public void setBalance(double balance) {
this.balance = balance;
}}
package day_01;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;/**
* 定时器 : 计划任务
*
* 只要有一个计划任务,就会开启一个线程,进行计时,到达指定时间后,由该线程来完成这个任务
*
* @author SEC90
* @Date 2022年1月24日 下午3:47:13
*/
public class Thread_09_Timer {
public static void main(String[] args) {
// 1 要做的事,也就是任务对象
// 2 什么时候开始做 , 1000*5 就是5秒之后开始
// 3 间隔时间,每隔多久做一次 1000*3 每3秒执行一次
Timer t = new Timer();
t.schedule(new LogTimerTask(), 1000*5,1000*3);
}
}// 创建任务
class LogTimerTask extends TimerTask {
@Override
public void run() {
Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String time = sdf.format(date);
System.out.println(time);
}
}本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
