JAVA视频学习笔记-马士兵(九)

最新推荐文章于 2024-09-09 21:58:55 发布
最新推荐文章于 2024-09-09 21:58:55 发布
阅读量167 收藏 1
点赞数
分类专栏： java视频（马士兵）学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/asdene/article/details/107311168
版权

`JAVA视频学习笔记-马士兵`

JAVA视频学习笔记(九)

线程_线程的基本概念(20200712)

  1. 线程的基本概念：
    线程、进程以及锁的概念　
    线程的基本概念
  2. 举例：。
public class {
	public static void main(String[] args) {
		m1();
	}
	
	public static  void m1() {
		m2();
		m3();
	}
	
	public static void m2() {}
	public static void m3() {}
}

执行路径有几条？
在这里插入图片描述什么叫进程：
静态概念，机器上的一个class文件，一个exe文件。

  1. 线程的创建和启动
    在这里插入图片描述
public class TestThread1 {
	public static void main(String args[]) {
		Runner1 r = new Runner1();
		r.start();
		//r.run();
		//Thread t = new Thread(r);
		//t.start();
		
		for(int i=0; i<100; i++) {
			System.out.println("Main Thread:------" + i);
		}
	}
}

//class Runner1 implements Runnable {
class Runner1 extends Thread {
	public void run() {
		for(int i=0; i<100; i++) {	
			System.out.println("Runner1 :" + i);
		}
	}
}

线程_Sleeping(20200713)

  1. 线程状态转换：。
    在这里插入图片描述
  2. 线程优先级：所谓的优先级是指优先级越高的过程它获得CPU的执行的时间就越多。
    在这里插入图片描述
  3. Sleeping方法 。
    在这里插入图片描述
import java.util.*;
public class TestInterrupt {
  public static void main(String[] args) {
    MyThread thread = new MyThread();
    thread.start();
    try {Thread.sleep(10000);}
    catch (InterruptedException e) {}
    thread.interrupt();
  }
}

class MyThread extends Thread {
	boolean flag = true;
  public void run(){
    while(flag){
      System.out.println("==="+new Date()+"===");
      try {
        sleep(1000);
      } catch (InterruptedException e) {
        return;
      }
    }
  }
}
/*
public void run() {
    while (true) {
      String temp = new Date().toString();
      String t = temp.substring(11, temp.indexOf('C'));
      t = t.trim();
      String[] time = t.split(":");
      if (time.length == 3) {
        System.out.println(“现在是” + time[0] + “点” + 
                  time[1] + "分" + time[2] + "秒");
      }
      try {
        Thread.sleep(5000);
      } catch (InterruptedException e) {
        return;
      }  
    }
  }
}
*/

线程_Join_Yield_Priority(20200714）

  1. Join_Yield_Priority：合并某个方法。
    在这里插入图片描述
public class TestJoin {
  public static void main(String[] args) {
    MyThread2 t1 = new MyThread2("abcde");
    t1.start();
    try {
    	t1.join();
    } catch (InterruptedException e) {}
    	
    for(int i=1;i<=10;i++){
      System.out.println("i am main thread");
    }
  }
}
class MyThread2 extends Thread {
  MyThread2(String s){
  	super(s);
  }
  
  public void run(){
    for(int i =1;i<=10;i++){
      System.out.println("i am "+getName());
      try {
      	sleep(1000);
      } catch (InterruptedException e) {
      	return;
      }
    }
  }
}
  1. Yield：让出CPU，给其他线程执行的机会。
    在这里插入图片描述
public class TestYield {
  public static void main(String[] args) {
    MyThread3 t1 = new MyThread3("t1");
    MyThread3 t2 = new MyThread3("t2");
    t1.start(); t2.start();
  }
}
class MyThread3 extends Thread {
  MyThread3(String s){super(s);}
  public void run(){
    for(int i =1;i<=100;i++){
      System.out.println(getName()+": "+i);
      if(i%10==0){
        yield();
      }
    }
  }
}
  1. Priority：线程的优先级。
    在这里插入图片描述

线程_线程同步1(20200715)

  1. 线程同步1： 什么是线程同步？线程为什么要同步？
    在这里插入图片描述
public class TestSync implements Runnable {
  Timer timer = new Timer();
  public static void main(String[] args) {
    TestSync test = new TestSync();
    Thread t1 = new Thread(test);
    Thread t2 = new Thread(test);
    t1.setName("t1"); 
    t2.setName("t2");
    t1.start(); 
    t2.start();
  }
  public void run(){
    timer.add(Thread.currentThread().getName());
  }
}

class Timer{
  private static int num = 0;
  public synchronized void add(String name){ 
  	//synchronized (this) {
	    num ++;
	    try {Thread.sleep(1);} 
	    catch (InterruptedException e) {}
	    System.out.println(name+", 你是第"+num+"个使用timer的线程");
	  //}
  }
}

在这里插入图片描述

线程_线程同步2(20200716)

  1. 锁：。　
    在这里插入图片描述

线程_线程同步3(20200717)

  1. 死锁：　　
    在这里插入图片描述举例：
public class TestDeadLock implements Runnable {
	public int flag = 1;
	static Object o1 = new Object(), o2 = new Object();
	public void run() {
System.out.println("flag=" + flag);
		if(flag == 1) {
			synchronized(o1) {
				try {
					Thread.sleep(500);
				} catch (Exception e) {
					e.printStackTrace();
				}
				synchronized(o2) {
					System.out.println("1");	
				}
			}
		}
		if(flag == 0) {
			synchronized(o2) {
				try {
					Thread.sleep(500);
				} catch (Exception e) {
					e.printStackTrace();
				}
				synchronized(o1) {
					System.out.println("0");
				}
			}
		}
	}	
	
	public static void main(String[] args) {
		TestDeadLock td1 = new TestDeadLock();
		TestDeadLock td2 = new TestDeadLock();
		td1.flag = 1;
		td2.flag = 0;
		Thread t1 = new Thread(td1);
		Thread t2 = new Thread(td2);
		t1.start();
		t2.start();
		
	}
}

在这里插入图片描述解决线程死锁的问题：最好只锁定一个对象，把锁的粒度加粗。

线程_线程同步4(20200718)

  1. synchronized：引入一道面试题。　　
    在这里插入图片描述

线程_线程同步5(20200719)

  1. 数据库的某一条记录或者某一个数字或者某一个对象，你可以改它也可以读它，哪个可以加synchronized？改的需要加，读的不用加。
public class TT implements Runnable {
	int b = 100;
	
	public synchronized void m1() throws Exception{
		//Thread.sleep(2000);
		b = 1000;
		Thread.sleep(5000);
		System.out.println("b = " + b);
	}
	
	public synchronized void m2() throws Exception {
		Thread.sleep(2500);
		b = 2000;
	}
	
	public void run() {
		try {
			m1();
		} catch(Exception e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) throws Exception {
		TT tt = new TT();
		Thread t = new Thread(tt);
		t.start();
		
		tt.m2();
		System.out.println(tt.b);
	}
}
  1. 在tt.java代码中给m2方法加上synchronized：　
    在这里插入图片描述

线程_线程同步6_生产者消费者问题(20200720)

  1. 用程序模拟以下过程：有人把馒头扔进桶里，有人从桶里把馒头拿出来吃掉(先进去的后拿出来)。　、
    栈：先进后出。
    　在这里插入图片描述面向对象：不要考虑里面的细节，考虑这里有哪些对象，哪些个类，这些对象和类有哪些方法！

public class ProducerConsumer {
	public static void main(String[] args) {
		SyncStack ss = new SyncStack();
		Producer p = new Producer(ss);
		Consumer c = new Consumer(ss);
		new Thread(p).start();
		new Thread(p).start();
		new Thread(p).start();
		new Thread(c).start();
	}
}

class WoTou {
	int id; 
	WoTou(int id) {
		this.id = id;
	}
	public String toString() {
		return "WoTou : " + id;
	}
}

class SyncStack {
	int index = 0;
	WoTou[] arrWT = new WoTou[6];
	
	public synchronized void push(WoTou wt) {
		while(index == arrWT.length) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.notifyAll();		
		arrWT[index] = wt;
		index ++;
	}
	
	public synchronized WoTou pop() {
		while(index == 0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.notifyAll();
		index--;
		return arrWT[index];
	}
}

class Producer implements Runnable {
	SyncStack ss = null;
	Producer(SyncStack ss) {
		this.ss = ss;
	}
	
	public void run() {
		for(int i=0; i<20; i++) {
			WoTou wt = new WoTou(i);
			ss.push(wt);
System.out.println("生产了：" + wt);
			try {
				Thread.sleep((int)(Math.random() * 200));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}			
		}
	}
}

class Consumer implements Runnable {
	SyncStack ss = null;
	Consumer(SyncStack ss) {
		this.ss = ss;
	}
	
	public void run() {
		for(int i=0; i<20; i++) {
			WoTou wt = ss.pop();
System.out.println("消费了: " + wt);
			try {
				Thread.sleep((int)(Math.random() * 1000));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}			
		}
	}
}

asdene
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
尚学堂马士兵java多线程部分笔记
天上的人我是谁的博客
04-13 796
一、线程进程的基本概念 略…… 二、线程调用方式 1、继承Thread类 public class Test { public static void main(String[] args) { // 执行多线程 MyThread thread = new MyThread(); thread.start(); // 执行...
JAVA视频学习笔记-马士兵(三)
asdene的博客
05-27 516
`JAVA视频学习笔记-马士兵`面向对象(20200511)面向对象(20200512)面向对象(20200513)面向对象(20200514)面向对象(20200515)面向对象(20200516)面向对象(20200517)面向对象(20200518)面向对象(20200519)面向对象(20200520)面向对象(20200521)面向对象(20200522)面向对象(20200523)面向对象(20200524) JAVA视频学习笔记(二) 面向对象(20200511) 编程语言的发展： 机器语
线程的基本概念-马士兵线程学习笔记
lovehello的专栏
07-11 302
理解线程 其实搞清楚线程和进程的关系就很好理解线程了。比如说你开一个微信，那微信就是一个进程， 但是微信里你同时和不同的人聊天，那不同的窗口就是一个个线程。线程实际就是可执行程序的最小单元， 是一个进程的不同执行路径。 线程的两种创建方式 线程的创建有很多种写法，但是归根结底就只有两种，一种是实现runnable接口，一种是继承Thread类 public class HowToCreateThread{ static class MyThread extends Thread{
JAVA视频学习笔记-马士兵(一)
asdene的博客
05-09 1628
`JAVA视频学习笔记-马士兵`新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 你好！ 这是你第一次使用 M...
JAVA笔记(根据马士兵的java视频整理).pdf
10-04
"JAVA笔记(根据马士兵的java视频整理)" 本资源是根据马士兵的JAVA视频整理的笔记，涵盖了JAVA的基础知识、数据结构、面向对象编程、Java Web编程、J2EE、J2ME等方面的知识点。 在基础知识方面，本资源涵盖了变量...
B站马士兵Python学习笔记（36页）
02-16
这篇笔记基于B站马士兵的Python入门基础版视频，旨在为有Java基础的学习者提供一个简洁明了的复习资料。通过阅读笔记，你可以快速回顾视频中的关键概念，同时也适合那些正在自学Python的人进行每日复习。 **第一章 ...
spring事务详细讲解-深入浅出
小电玩
09-08 325
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1322
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1306
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
自定义Stater
m0_63624484的博客
09-07 654
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
基于JavaWeb开发的JavaSpringboot+Vue实现前后端分离房屋租赁系统
央顺科技官方博客
09-05 515
2021年处于信息科技高速发展的大背景之下。在今天，缺少手机和电脑几乎已经成为不可能的事情，人们生活中已经难以离开手机和电脑。针对增加的成本管理和操作,各大商家非常有必要建立自己的网上房屋租赁平台系统，这既可以让更多的人体验到网络所带来的方便，也有助于提高房屋的租赁。在经过几十年的高速发展后，互联网已成为最流行、最普及的媒体，每天的信息流量甚至能比得上过去十年。其以便捷的信息交换、快速的沟通速度，悄然地改变着会员的消费方式。
MyBatis面试
Tony_yitao的博客
09-09 410
MyBatis面试
SpringBoot总结
2302_77073236的博客
09-06 191
都做成图了，方便理解和掌握全局关系。
Web安全之文件上传漏洞和案例示范
最新发布
weixin_39996520的博客
09-09 608
在Web应用程序中，文件上传功能广泛应用，特别是在电商交易系统中，用户上传商品图片、订单文件等操作十分常见。然而，文件上传功能若未被妥善处理，将成为攻击者利用的突破口。本文将以电商交易系统为例，深入分析文件上传过程中的常见安全漏洞，提供相应的解决方案。
【计算机毕业设计】高校课堂教学管理系统
weixin_47772925的博客
09-04 1130
2.1Java是由SUN公司推出，该公司于2010年被oracle公司收购。Java本是印度尼西亚的一个叫做爪洼岛的英文名称，也因此得来java是一杯正冒着热气咖啡的标识。Java语言在移动互联网的大背景下具备了显著的优势和广阔的前景，它是面向对象的，分布式的，动态的，具有平台无关性、安全性、健壮性。Java语言的基本语句语法和C++一样，但是它面向对象的技术更加彻底，因为Java要求将所有的内容都必须封装成类，把类作为程序的基本单位。由于不允许类外有变量、方法。
从内存层面分析Java 参数传递机制
weixin_54574094的博客
09-06 874
基本数据类型的参数传递是值传递，修改方法内部的值不会影响外部变量，因为每个方法调用都有自己的栈帧。引用数据类型的参数传递是引用传递，修改方法内部的对象内容会影响外部变量，因为它们指向同一个对象。栈帧中的引用指向相同的对象内存地址。String类型是不可变的，对String对象的修改会创建一个新的对象，原始对象保持不变，这与对象的可变性相关。
Java中项目名、包名、类名、接口名、方法名、类名命名规范（简单示范）
weixin_70495659的博客
09-08 231
【代码】Java中项目名、包名、类名、接口名、方法名、类名命名规范（简单示范）
马士兵Java Hibernate框架深度学习笔记
"马士兵的Java框架学习笔记专注于讲解Hibernate，提供了一个系统的学习路径，从基础到高级，包括HelloWorld示例、ORMapping原理、配置、ID生成策略、查询语言HQL以及性能优化等关键点。笔记强调了Annotation的使用，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值