线程入门-----

最新推荐文章于 2024-04-26 14:00:07 发布

白白♛～

最新推荐文章于 2024-04-26 14:00:07 发布

阅读量1k

点赞数 13

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/2301_77565910/article/details/137071832

版权

1、进程和线程

什么是进程呢?
一个运行的程序就可以称为进程关闭这个应用程序这个进程就会自动的关闭
什么是线程呢?
线程是进程的一个模块
从概念上来讲的话进程中是包含线程的....
从实例上来讲的话、用百度网盘下载的这个例子来说每一个下载项都可以看成是一个线程
线程的出现是为了充分的去利用CPU 最终的目的是为了提高效率
线程的出现是为了异步：
同步：我要找王晨办事、王晨你把教室打扫了... 我就会一直等待王城去打扫这个教室.... 直到这个教室打扫完成再去做下一件事
同步容易出现什么问题：同步的话是容易出现阻塞的
异步：我要找王晨办事、王晨你把教室打扫了... 我知道王晨一定会打扫至于什么时候打扫我不关心，我吧这件事安排给他就可以了然后就去做自己的事情了...
异步是不会出现阻塞的
线程的使用一定是为了提高CPU的利用率，并不是线程越多越好因为线程越多那么线程的上下文切换锁需要消耗的资源越多。。。这样效率不一定高
我们所学习的线程是属于：系统级线程不是用户级线程
如果是用户级线程那么整个线程的调度都需要用户编写代码来完成我们学习的是系统级线程整个线程的调度是由操作系统来完成的....

2、并发和并行

并发：
一个线程执行一会儿这个叫做并发
按照时间片来轮转的进行执行这个叫做并发

并行：一起执行这个称为并行
所有的线程同时实行

3、继承Thread类实现线程

public class Demo1 {

/**
* 这个主程序在运行的时候也会自动的开启一个线程这个线程就叫做主线程 main
*
* @param args
*/
public static void main(String[] args) {
//打印线程的名字
System.out.println(Thread.currentThread().getName());

//实例化一个线程对象
MyThread myThread = new MyThread();
myThread.setName("子线程xxx");
myThread.start();

System.out.println("主线程执行完成....");
}

}

/**
* 线程的第一种实现方式
* 继承Thread类重写 run方法
*/
class MyThread extends Thread {
@Override
public void run() {
//这里就是编写业务逻辑的地方
while (true) {
System.out.println("我是自定义线程....:线程名字:"+Thread.currentThread().getName());
try {
//睡眠一会儿每次打印完成之后休眠500毫秒再打印
Thread.sleep(500);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}

4、多线程机制(线程监控JConsle)

public class Demo1 {

/**
* 这个主程序在运行的时候也会自动的开启一个线程这个线程就叫做主线程 main
*
* 主线程死了是不会影响子线程的运行的....
* 如果当前的进程所有线程都死了那么金才会让你个也会被关闭....
*
* @param args
*/
public static void main(String[] args) throws InterruptedException {
//打印线程的名字
System.out.println(Thread.currentThread().getName());

//实例化一个线程对象
MyThread myThread = new MyThread();
myThread.setName("子线程xxx");
myThread.start();

//这句代码用在哪里就表示哪里需要休眠(比如在这里就表示主线程休眠20s)
Thread.sleep(20000);
System.out.println("主线程执行完成....");
}

}

/**
* 线程的第一种实现方式
* 继承Thread类重写 run方法
*/
class MyThread extends Thread {
int count=0;
@Override
public void run() {
//这里就是编写业务逻辑的地方
while (true) {
System.out.println("我是自定义线程....:线程名字:"+Thread.currentThread().getName());
try {
//睡眠一会儿每次打印完成之后休眠500毫秒再打印
Thread.sleep(500);
if(count++>=50){
break;
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
System.out.println("子线程over了....");
}
}

5、为什么启动方法是start

当线程启动的时候调用了一个start0()的方法

private native void start0();

这个start0()的方法是一个native修饰的方法 JNI(Java native interface)

JNL是Java语言调用其他语言的接口在申明的时候就申明成 native修饰的方法

简单的说这个start0()的底层就是C语言和C++写的... 这个C和C++写的这个代码实际上就去请求了CPU创建这个线程....

如果是直接调用了 run()方法的话这个就是Java中简单的一个方法的调用不涉及到 CPU对线程的创建所以我们在启动线程的时候都要去调用start()方法

6、Rnnable方式创建线程

继承Thread和实现Runable接口的线程都是没有返回值的

public class Demo2 {

static int count=0;

/**
* 实现Runnable接口实现线程的创建
* @param args
*/
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(new MyRunnable());
thread.setName("子线程01");
thread.start();
//这里我可以在主线程中一直打印一个数据
while (true){
System.out.println("主线程计数:"+(count++));
Thread.sleep(500);
if(count>50){
System.out.println("主线程over了...");
break;
}
}

}
}

/**
* 实现Runable接口实现线程的创建
*/
class MyRunnable implements Runnable{
int count=0;
public void run() {
while (true){
System.out.println("子线程线程执行了....:"+Thread.currentThread().getName());
count++;
try {
Thread.sleep(500);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
if(count>60){
System.out.println("子线程over了...");
break;
}
}
}
}

7、Callable创建线程(学习)

Callable方式和上面的继承Thread和实现Runnable接口有一个最大的区别?

这个Callable实现的线程私有返回值的所以他经常所使用的场景就是异步计算

public class Demo3 {

private static Integer a = 1;
private static Integer b = 2;

public static void main(String[] args) throws ExecutionException, InterruptedException {
//第一步：创建这个Callable的实例对象
MyCallable myCallable = new MyCallable();
//第二步：按照我们的逻辑：只有Thread这个类中有这个方法
FutureTask<Integer> futureTask = new FutureTask<Integer>(myCallable);
Thread thread = new Thread(futureTask);
thread.start();
//取出这个返回的结果
//下面的这个get()方法是会被阻塞的知道等到结果的到来
System.out.println("我正在等待....");
Integer integerVal = futureTask.get();
System.out.println("异步执行的结果是:" + integerVal);
}

static class MyCallable implements Callable<Integer> {
/**
* 这个Call方法就是业务编写的方法
*
* @return
* @throws Exception
*/
public Integer call() throws Exception {
System.out.println("call正在执行...");
Thread.sleep(30000);
System.out.println("call执行结束...");
return a + b;
}
}
}

7、多个子线程实例

public class Demo4 {

public static void main(String[] args){
/* for (int i = 1; i <6 ; i++) {
MyThread1 myThread1 = new MyThread1(i);
myThread1.setName("线程:"+i);
myThread1.start();
}*/

for (int i = 1; i <6 ; i++) {
MyRunable1 myRunable1 = new MyRunable1(i);
Thread thread = new Thread(myRunable1);
thread.setName("线程:"+i);
thread.start();
}
}

}

class MyRunable1 implements Runnable{
private Integer id;

public MyRunable1(Integer id){
this.id=id;
}
public void run() {
System.out.println("线程:"+Thread.currentThread().getName()+"---正在执行-编号是:"+this.id);
}
}

/**
* 线程的Thread创建
*/
class MyThread1 extends Thread{
//给一个id标识
private Integer id;

public MyThread1(Integer id){
this.id=id;
}
@Override
public void run() {
System.out.println("线程:"+Thread.currentThread().getName()+"---正在执行-编号是:"+this.id);
}
}

8、多线程售票问题

票的超卖是如何产生的

这种情况其实称为：线程安全问题

什么是线程安全问题呢?

多个线程访问了同一个共享变量并改变了他这种情况下就存在线程安全问题

public class Demo1 {

public static void main(String[] args) {
//开始开启窗口卖票
for (int i = 1; i <= 5; i++) {
TicketThread ticketThread = new TicketThread(i);
ticketThread.start();
}
}
}

/**
* 售票的线程
* 每一个实例都是一个窗口
*/
class TicketThread extends Thread {

//这个代表的是票的总数 static：所有的线程实例都可以刚问
private static int ticketNum = 200;

//窗口编号
private int num;

public TicketThread(int num) {
this.num = num;
}

@Override
public void run() {
while (true) {
try {
//模拟了卖票需要花费时间
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
if (ticketNum == 0) {
//就无票可卖了...
System.out.println(num + "窗口买票结束");
break;
}
System.out.println("窗口:" + num + "--买的票的编号是:" + (ticketNum--));
}
}
}

9、线程退出

1、线程执行完成之后自动退出

2、设置标记当他达到条件的时候直接将标记置为false 让线程优雅的结束

public class Demo1 {
public static void main(String[] args) {
new MyThread1().start();
}
static class MyThread1 extends Thread {
//boolean loop = true;
int count = 0;
@Override
public void run() {
while (true) {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("线程名字:" + Thread.currentThread().getName() + "---:执行:" + (count++));
if (count > 50) {
// break;
//return;
// throw new RuntimeException("结束线程....");
}
}
}
}
}

10、线程中断

线程的中断一定要记住是中断不是终止....

这里的中断一般是用在 sleep上的终止是让整个线程结束中断没有结束

public class Demo1 {

public static void main(String[] args) throws InterruptedException {
MyThread1 myThread1 = new MyThread1();
myThread1.start();
Thread.sleep(5000);
myThread1.interrupt();
}

static class MyThread1 extends Thrsead {
int count = 0;
@Override
public void run() {
try {
Thread.sleep(20000);
} catch (InterruptedException e) {
//throw new RuntimeException(e);
System.out.println("执行到了这里来了....");
}
System.out.println("线程名字:" + Thread.currentThread().getName());
}
}
}

10、线程插队

Thread.yield();
线程礼让：这个方法不一定能礼让成功真正的能不能礼让跟CPU资源有关系如果是CPU的资源充足那么就不会礼让成功如果是CPU的资源不充足那么才会礼让成功...
myThread1.join();
加进来：插队

10.1、使用Join让这个线程实现插队

public class Demo1 {

/**
* 现在的要求是 MyThread2执行到10次的时候让线程3进行插队运行完成之后自己再执行
*
* @param args
*/
public static void main(String[] args) {

MyThread3 myThread3 = new MyThread3();
myThread3.setName("线程2");

//现在创建第一个线程对象
MyThread2 myThread2 = new MyThread2(myThread3);
myThread2.setName("线程1");

myThread2.start();
myThread3.start();

}

class MyThread3 extends Thread {
private int count = 0;

@Override
public void run() {
while (true) {
if (count >= 50) {
break;
}
try {
Thread.sleep(200);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("线程:" + Thread.currentThread().getName() + "---正在打印:" + (count++));
}
System.out.println("线程:" + Thread.currentThread().getName() + "---执行完成");
}
}

/**
* 定义的线程类
*/
class MyThread2 extends Thread {

//线程2的线程类对象
private MyThread3 myThread3;
private int count = 0;

public MyThread2(MyThread3 myThread3) {
this.myThread3 = myThread3;
}

@Override
public void run() {
while (true) {
if (count == 10) {
//需要让线程2执行完成自己再执行
try {
myThread3.join();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}

if (count >= 50) {
break;
}
try {
Thread.sleep(200);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("线程:" + Thread.currentThread().getName() + "---正在打印:" + (count++));
}
System.out.println("线程:" + Thread.currentThread().getName() + "---执行完成");
}
}

10.2、使用pack和unpack实现同样的功能

import java.util.concurrent.locks.LockSupport;

public class Demo2 {

/**
* 现在的要求是 MyThread2执行到10次的时候让线程3进行插队运行完成之后自己再执行
*
* @param args
*/
public static void main(String[] args) {

//现在创建第一个线程对象
MyThread5 myThread5 = new MyThread5();
myThread5.setName("线程1");

MyThread4 myThread4 = new MyThread4(myThread5);
myThread4.setName("线程2");

myThread4.start();
myThread5.start();
}

}

/**
* 线程1
*/
class MyThread4 extends Thread {
private int count = 0;

private MyThread5 myThread5;

public MyThread4(MyThread5 myThread5){
this.myThread5=myThread5;
}

/**
* 定义的线程类(线程2)
*/
class MyThread5 extends Thread {
private int count = 0;
@Override
public void run() {
while (true) {
if (count == 10) {
//让线程休眠(让程序阻塞起来)
LockSupport.park();
}
if (count >= 50) {
break;
}
try {
Thread.sleep(200);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("线程:" + Thread.currentThread().getName() + "---正在打印:" + (count++));
}
System.out.println("线程:" + Thread.currentThread().getName() + "---执行完成");
}
}

13、线程同步机制

我们在开发的时候经常遇到这个场景：
就是某一个业务操作在同一个时间只允许一个线程去运行.... 如果多个线程去更改了这一个数据的话那么很容易造成线程安全问题 ....
这个线程安全问题的解决方案：就是加锁
如果你不理解解锁是什么意思:我们可以看下生活中的例子：上厕所

假设这个厕所只由一个坑... 那么你想上厕所的过程是啥呢?
一开始很多人都想上厕所 ... 结果同一时间只能有一个人上厕所
张三拉开门上测试上三上完厕所关闭们李四拉开门上测试李四关闭厕所门.... 这个就是一个锁的经典案例

线程在运行的时候也是这个过程我们不是说了吗同一时间只有一个线程执行.....

无数个线程来请求我们的方法结果只有一个人拿到锁那么其他人只能等待... 只有等这一个线程完成操作并且释放了锁那么其余的人才有机会拿到这个锁执行业务释放锁依次这个过程就是线程同步的过程....
这个家伙的实质是:将并行的请求串行化了....

什么是锁呢?
锁其实就是一个数据的状态 state=0
谁把这个数据从0变成1 成功呢么你就拥有这个锁你执行业务业务执行完成... 再由1变成0
于是其他的人又能从0---》1 于是其他的线程就获取到这个锁了....

synchronized

13.1、synchronized修饰静态方法

public class Demo1 {
public static int count = 200; public static void main(String[] args) {
for (int i = 0; i < 20; i++) {
new MyThread().start();
}
}

static class MyThread extends Thread {
@Override
public void run() {
while (true) {
if (count <= 0) {
break;
}
sellTicket();
try {
Thread.sleep(200);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
System.out.println("票已经卖完....");
}
}

/**
* synchronized修饰静态方法的话那么
* 锁的对象是当前类的class对象
* class对象是这个类的字节码对象(Class 对象就是当前类被JVM加载之后的这个对象) 不是类的对象(new Demo1())
* 下面的synchronized表示同一时间只能有一个线程来执行下面的方法
*
* 锁都有锁对象
*
*/
private static synchronized void sellTicket() {
if(count>0){
System.out.println("当前售卖的票是:" + (count--));
}
}
}

13.2、synchronized修饰普通方法

public class Demo2 {
public static int count = 200;

/**
* 这种运行方法的方式实际上是通过类的对象.方法来进行访问的
*/
@Test
public void testSynchronized(){
for (int i = 0; i <10 ; i++) {
new MyThread().start();
}

try {
Thread.sleep(Integer.MAX_VALUE);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}

class MyThread extends Thread {
@Override
public void run() {
while (true) {
if (count <= 0) {
break;
}
sellTicket();
}
System.out.println("票已经卖完....");
}
}

/**
* synchronized：这个表示的是synchronized修饰我们的非静态的方法
* 修饰非静态的方法的时候这个锁对象是：当前类的对象 this
*/
private synchronized void sellTicket() {
if (count > 0) {
System.out.println("当前售卖的票是:" + (count--));
}
}
}

13.3、synchronized修饰任意一段代码

public class Demo3 {
public static int count = 200;

/**
* 这种运行方法的方式实际上是通过类的对象.方法来进行访问的
*/
@Test
public void testSynchronized() {
for (int i = 0; i < 10; i++) {
new MyThread().start();
}

try {
Thread.sleep(Integer.MAX_VALUE);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}

class MyThread extends Thread {
@Override
public void run() {
while (true) {
if (count <= 0) {
break;
}
/**
* synchronized修饰一段代码的时候这个时候的锁对象可以是任意的对象
* 一般做开发的时候我们在添加锁的时候都去锁定代码而不是整个的方法因为这样的
* 锁的力度是最细粒度的效率就比较高
*/
synchronized ("锁") {
if (count > 0) {
System.out.println("当前售卖的票是:" + (count--));
}
}
}
System.out.println("票已经卖完....");
}
}
}

13.4、锁的粗化

@Test
public void testSynchronized() {

/**
* 下面只是加锁了一次....
*/
synchronized ("锁"){
synchronized ("锁"){
synchronized ("锁"){
System.out.println("加了几次锁....");
}
}
}
}

13.5、锁的失效

@Test
public void testSynchronized() {
for (int i = 0; i < 20; i++) {
new Thread(new Runnable() {
public void run() {
/**
* 因为每没来一个线程这个锁的对象都会从新创建
* 所以这种情况下锁会失效
*/
synchronized (new User()) {
System.out.println("小波波最帅....");
}
}
}).start();
}
}

14、售票案例的修改(略)

15、死锁

线程之间相互持有对象的锁资源不释放这样就会造成死锁问题

比如我们班有遥控器隔壁班有电池

隔壁班需要我们的遥控器才能开空调我们班需要隔壁的电池才能开空调这种相互持有对方锁资源的情况就会造成死锁

死锁是没有解决方案的只能尽量的避免

public class Demo1 {
public static void main(String[] args) {
//这个是我们班
new Thread(new Runnable() {
public void run() {
synchronized ("遥控器") {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
synchronized ("电池") {
System.out.println("我们班优哉游哉的开启了空调....");
}
}
}
}).start();

//这个是隔壁班
new Thread(new Runnable() {
public void run() {
synchronized ("电池") {
synchronized ("遥控器") {
System.out.println("隔壁班优哉游哉的开启了空调....");
}
}
}
}).start();
}
}

16、生产者和消费者模型(了解)

原本意义上来说这个是线程之间的通信

A----->B B----->A

最经典的模型就是生产者和消费者模型....

生产者生产---->通知消费者消费----->消费完成再通知生产者生产---->消费者消费----通知生产者生产...

我们以生产包子为例给大家讲一讲这个生产者和消费者模型的问题

里面涉及到三个方法

这些方法是Java中用于线程同步的方法。 wait() 方法使当前线程等待，直到另一个线程调用对象的 notify() 或 notifyAll() 方法来唤醒它。 notify() 方法唤醒在对象上调用 wait() 方法的单个线程，而 notifyAll() 方法唤醒所有在对象上调用 wait() 方法的线程。这些方法通常与 synchronized 关键字一起使用，以实现线程之间的协调和同步。

说下这些方法是 Object对象中的方法

我们要写这样一个例子
需要三个生产者

需要两个消费者

放东西的地方(桌子上)

import java.util.ArrayList;
import java.util.List;

public class Desk {

//这个就是桌子上存放包子的容器
private List<String> list = new ArrayList<String>();

/**
* 生产者放东西的方法
*/
public synchronized void push() {
if (list.size() == 0) {
//说明盘子是空的
//首先获取线程的名字
String name = Thread.currentThread().getName();
//向集合中放数据
list.add(name + "放了一个包子....");
System.out.println(name+"放了一个包子...");
try {
Thread.sleep(500);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
//放完了之后要自己阻塞住通知消费者来消费
//记住这里有个顺序：先通知消费者消费再阻塞自己
try {
this.notifyAll();
this.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
} else {
try {
this.notifyAll();
this.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}

}

/**
* 取包子的方法
*/
public synchronized void pull() {
//首先是有包子才能取出这个包子
if (list.size() == 1) {
String s = list.get(0);
String threadName = Thread.currentThread().getName();
System.out.println(threadName + "取出了一个包子");
//说明有包子取出这个包子
list.clear();
try {
//这里还要注意一定是先唤醒别人然后阻塞自己
this.notifyAll();
this.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
} else {
//说明没有包子了....
try {
this.notifyAll(); //这个方法会将所有调用了 this.wait()方法的线程全部唤醒
this.wait(); //这个表示的是自己释放锁资源并阻塞
//this.notify(); 这个表示的是唤醒一个调用了 this.wait()方法的线程
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}

}
}

16.2、编写测试类

public class Demo1 {
public static void main(String[] args) {

final Desk desk = new Desk();

//第一个生产者
Thread thread = new Thread(new Runnable() {
public void run() {
while (true){
desk.push();
}
}
});
thread.setName("厨师1");
thread.start();

//第二个生产者
Thread thread2 = new Thread(new Runnable() {
public void run() {
while (true){
desk.push();
}
}
});
thread2.setName("厨师2");
thread2.start();

//第三个生产者
Thread thread3 = new Thread(new Runnable() {
public void run() {
while (true){
desk.push();
}
}
});
thread3.setName("厨师3");
thread3.start();

//第一个吃货
Thread thread4 = new Thread(new Runnable() {
public void run() {
while (true){
desk.pull();
}
}
});
thread4.setName("吃货1");
thread4.start();

//第二个吃货
Thread thread5 = new Thread(new Runnable() {
public void run() {
while (true){
desk.pull();
}
}
});
thread5.setName("吃货2");
thread5.start();
}
}

白白♛～

关注

13
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
线程入门-----

System.out.println("线程名字:" + Thread.currentThread().getName() + "---:执行:" + (count++));System.out.println("线程:" + Thread.currentThread().getName() + "---正在打印:" + (count++));System.out.println("线程:"+Thread.currentThread().getName()+"---正在执行-编号是:"+this.id);
复制链接

扫一扫