JavaSE(十二)--线程

最新推荐文章于 2021-12-09 13:38:49 发布
最新推荐文章于 2021-12-09 13:38:49 发布
阅读量100 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49349430/article/details/110411388
版权

一、线程基础

1.进程

系统进行资源分配和调用独立单元.每个进程都有自己系统资源的内存空间.
(正在运行的程序)
在这里插入图片描述

2.线程

进程中一条执行线路.一个线程执行一个任务.
在这里插入图片描述

3.进程与线程的关系

一个进程中可以1到多个线程.一个线程只属于一个进程.
一个进程中多个线程之间是互抢资源竞争关系.

4.实现线程

有三种实现方式,前两种公司常用,第三种基本不用.

  • 第一种实现线程的方式:继承Thread类
public class MyThread extends Thread{
	/**
	 * 重写线程类的任务方法
	 */
	@Override
	public void run() {
		for (int i = 1; i <= 10; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
}

public static void main(String[] args) {
		//创建线程对象		
		MyThread t1=new MyThread();
		MyThread t2=new MyThread();
		
		//启动线程
		t1.start();
		t2.start();
}
  • 第二种实现线程的方式:实现Runnable接口
/**
 * 线程的任务类
 */
public class MyRunnable implements Runnable{
	/**
	 * 重写任务方法
	 */
	@Override
	public void run() {
		for (int i = 1; i <=10; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
}

public static void main(String[] args) {
		//创建任务对象
		MyRunnable r1=new MyRunnable();
		MyRunnable r2=new MyRunnable();
		
		//将任务对象构建成线程对象
		Thread t1=new Thread(r1);
		Thread t2=new Thread(r2);
		
		//启动线程
		t1.start();
		t2.start();
	}
  • (了解)第三种实现线程方式:实现Callable
/**
 * 任务类的前身
 */
public class MyCallable implements Callable{
	/**
	 * 任务方法
	 */
	@Override
	public Object call() throws Exception {
		for (int i = 1; i <=10; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
		return null;
	}
}
		public static void main(String[] args) {
		//创建Callable对象
		MyCallable m1=new MyCallable();
		MyCallable m2=new MyCallable();
		
		//将Callable对象封装成任务对象
		FutureTask task1=new FutureTask(m1);
		FutureTask task2=new FutureTask(m2);
		
		//将任务对象封装成线程对象
		Thread t1=new Thread(task1);
		Thread t2=new Thread(task2);
		
		//启动线程
		t1.start();
		t2.start();
	}

5.继承Thread VS 实现Runnable接口的方式实现多线程(面试)

  • 代码简洁性:继承Thread方式代码更简洁;实现Runnable接口的方式代码稍麻烦点.
  • 代码可扩展性:继承Thread方式不能再继承其他类,只能实现其他接口,所以扩展性稍差.实现Runnable接口的方式还可以继承其他的类,实现其他的接口,扩展性稍好.
  • 资源共享性:继承Thread方式,只能通过静态属性来实现多个线程对象共享同一个资源,
    比较耗内存;实现Runnable接口的方式,只需要多个线程共用一个任务对象就能 实现资源共享.

6.给线程取名:

6.1:构造方法给线程取名.

//通过构造方法给线程取名
	public MyThread(String name) {
		this.setName(name);
	}

6.2:调用setName()给线程取名

6.3:给线程用默认名字

System.out.println(Thread.currentThread().getName()+":"+i);

6.4:在线程类中声明一个成员变量存线程名称

7.(重点)线程休眠

让当前线程停止资源抢夺,等时间到了,重新参加资源抢夺.

  • 类名.sleep(毫秒);(推荐)
  • 对象名.sleep(毫秒);
/**
 * 从6输出到1,每隔一秒输出一个数
 */
public class SleepTest {
	public static void main(String[] args) throws InterruptedException {
		for (int i = 6; i >=1; i--) {
			System.out.println(i);
			//每输入一个数,睡眠一秒
			Thread.sleep(1000);
		}
	}
}

8.线程优先级:

优先级越高的线程抢占资源的概率越高,但是不一定抢得到;优先级越低线程抢占资源的概率越低,但是不一定抢不到.注意:在启动线程之前设置才有效.

  • 对象.setPriority(int newPriority)
public static void main(String[] args) {
		
		//创建线程对象
		MyThread t1=new MyThread();
		MyThread t2=new MyThread();
		//设置线程优先级
		t1.setPriority(Thread.MIN_PRIORITY);//最低优先级
		t2.setPriority(Thread.MAX_PRIORITY);//最高优先级
		
		//启动线程
		t1.start();
		t2.start();
	}

9.(重点)线程合并

让两个或以上的线程合并为一个线程执行,合并过来的线程先执行完, 再执行原来的线程.

9.1:子线程合并到主线程中

在合并前,子线程与主线程是互抢资源的竟争关系,合并后变成一 个线程,只是合并后,子线程先执行完再执行主线程.

/**
 * 线程类
 */
public class MyThread extends Thread{
	/**
	 * 重写父类中任务方法
	 */
	@Override
	public void run() {
		for (int i = 1; i <=100; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
}

public static void main(String[] args) throws InterruptedException {
		//创建子线程
		MyThread t1=new MyThread();
		
		//启动线程
		t1.start();
		
		
		for (int i = 1; i <=100; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
			//当主线程运行到10的时候,子线程合并过来
			if (i==10) {
				t1.join();
			}
		}
	}

9.2:子线程A合并子线程B中

在合并前,两个子线程是互抢资源的竟争关系,合并后变成一个线程,只是合并后,子线程A先执行完再执行子线程B.

public class MyThread2 extends Thread{
	//声明一个成员变量,用来传线程对象
	public MyThread2 t;
	
	/**
	 * 重写父类中任务方法
	 */
	@Override
	public void run() {
		for (int i = 1; i <=100; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
			if (i==10&&Thread.currentThread().getName().equals("线程B")) {
				try {
					//this指代线程B,this.t存线程A
					this.t.join();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}

public static void main(String[] args) {
		//创建线程对象
		MyThread2 ta=new MyThread2();
		ta.setName("线程A");
		MyThread2 tb=new MyThread2();
		tb.setName("线程B");
		tb.t=ta;
		
		//启动线程
		ta.start();
		tb.start();
	}

10.线程礼让

让当前线程让出资源,再重新参加抢夺资源.

  • 类名.yield() (推荐)
  • 对象.yield()
public static void main(String[] args) {
		//创建子线程对象
		MyThread t1=new MyThread();
		//启动线程
		t1.start();
		
		for (int i = 1; i <=10; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
			Thread.yield();
		}
	}

11.线程中断

11.1:用中断方法interrupt(),isInterrupted()

/**
 * 线程类
 */
public class MyThread extends Thread{
	/**
	 * 重写父类中任务方法
	 */
	@Override
	public void run() {
		for (int i = 1; i <=100; i++) {
			//判断中断状态
			if (Thread.currentThread().isInterrupted()==true) {
				System.out.println(Thread.currentThread().getName()+"中断成功了");
				break;
			}
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
}

public static void main(String[] args) throws InterruptedException {
		//创建子线程
		MyThread t1=new MyThread();
		//启动线程
		t1.start();
		
		for (int i = 1; i <=100; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
			if (i==10) {//当主线程运行10时候,中断子线程,让子线程再也不执行
				//改变子线程的中断状态
				t1.interrupt();
				//主线程让出资源
				Thread.sleep(3000);
			}
		}
	}

11.2:声明一个成员变量作为叫断标记

/**
 * 线程类
 */
public class MyThread extends Thread{
	//声明一个变量作标记
	boolean flag=false;//标记不中断
	
	/**
	 * 重写父类中任务方法
	 */
	@Override
	public void run() {
		for (int i = 1; i <=100; i++) {
			//判断中断状态
			if (flag) {
				System.out.println(Thread.currentThread().getName()+"已经中断了");
				break;
			}
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
}

public static void main(String[] args) throws InterruptedException {
		//创建子线程
		MyThread t1=new MyThread();
		//启动线程
		t1.start();
		
		for (int i = 1; i <=100; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
			if (i==10) {//当主线程运行10时候,中断子线程,让子线程再也不执行
				//改变子线程的中断状态
				t1.flag=true;
				//主线程让出资源
				Thread.sleep(3000);
			}
		}
	}

12.(扩展)守护线程(后台线程,精灵线程)

守护同一个进程中所有非守护线程,如果所有非守护线程 死亡了,守护线程也死亡了.

  • 对象.setDaemon(true) ;
    注意: 设置守护线程一定要在启动线程之前设置.

13.线程生命周期:(面试)

新建状态:当你New出来一个线程对象时,这个线程就处于新建状态.
就绪状态:当线程调用start()或线程sleep()的时间到了,等待的线程被唤醒就处于就绪状态.
运行状态:当线程执行run()时就处于运行状态.
阻塞状态:当线程调用sleep()或wait()时,线程处于阻塞.
死亡状态:当线程不再执行,就处于死亡状态.

在这里插入图片描述

二、线程安全和线程池

1.线程池的作用

节省创建线程和销毁线程所需要时间.

2.线程池

存放多个线程的容器叫线程池.

3.线程池常用接口和类

3.1:ExecutorService:线程池接口

  • 常用方法:
    shutdown()关闭线程池
    submit(Runnable task) 从线程池中拿出一个线程对象来执行任务

3.2:Executors:线程池工具类对象

  • 常用方法:
    • 1:newCachedThreadPool();创建一个可缓存的线程池,可随机创建线程对象,线程对象在1min内可以循环使用,如果1min内无任务执行,就会自动回收这个线程对象.
    • 2:newSingleThreadExecutor();创建只有一个线程对象的线程池.
    • 3:newFixedThreadPool(int nThreads);创建指定线程数量的固定大小线程池

3.3:线程池的使用:

public static void main(String[] args) {
		//创建一个线程对象的线程池对象,用父接口作为数据类型,用线程池工具类创建子类对象
		//ExecutorService pool1=Executors.newSingleThreadExecutor();
		//创建固定大小线程数的线程池对象
		//ExecutorService pool1=Executors.newFixedThreadPool(2);
		//创建可缓存的线程池
		ExecutorService pool1=Executors.newCachedThreadPool();
		
		//创建一个任务对象
		Runnable r1=new Runnable() {
			/**
			 * 任务方法
			 */
			@Override
			public void run() {
				for (int i = 1; i <=10; i++) {
					System.out.println(Thread.currentThread().getName()+":"+i);
				}
			}
		};
		
		//创建一个任务对象
		Runnable r2=new Runnable() {
			/**
			 * 任务方法
			 */
			@Override
			public void run() {
				for (int i = 1; i <=10; i++) {
					System.out.println(Thread.currentThread().getName()+":"+i);
				}
			}
		};
		
		//创建一个任务对象
		Runnable r3=new Runnable() {
			/**
			 * 任务方法
			 */
			@Override
			public void run() {
				for (int i = 1; i <=10; i++) {
					System.out.println(Thread.currentThread().getName()+":"+i);
				}
			}
		};
		
		//从线程池中取出线程对象执行任务
		pool1.submit(r1);
		pool1.submit(r2);
		pool1.submit(r3);
		
		//关闭线程池
		pool1.shutdown();
	   }

4.临界资源问题

当多个线程共享同一个资源时,一个线程抢到了资源,操作了还没来得及修改,另一 个线程又把这个共享资源抢走,这就出现临界资源问题.

5.解决临界资源问题,要用到线程同步.

cpu时间片:进程中系统资源和内存空间.

6.线程同步

让需要一起执行的代码,放在一个代码块中,每次只允许一个线程进去这个代码块执行,如果有一个线程进入代码块执行,其他线程只能在外面等待,等代码块中线程执行完且抢到cpu时间片,另一个线程才能进入代码块中执行.

7.线程同步的方式:

7.1:同步代码块

需要一起执行的代码,放在一个代码块中,每次只允许一个线程进去这个代码 块执行,上锁,如果有一个线程进入代码块执行,其他线程只能在外面等待,等代码块中线程执行完,自动解锁.谁先抢到cpu时间片,哪个线程才能进入代码块中执行,重新上锁.

  • 1:语法
	synchronized(锁对象){
			(锁的范围)需要一起执行的代码
	 }
  • 2:同步代码块中锁对象可以是任何对象,只要是这多个线程共用的一个对象,都可以作为锁对象.锁对象的值最好是固定不变.
  • 3:锁的范围越小越好.
/**
 * 任务类
 */
public class MyRunnable implements Runnable{
	public int ticket=1000;
	//创建一个对象作为锁对象,这个进程中所有对象共享
	public final Object ob=new Object();

	/**
	 * 重写任务方法
	 */
	@Override
	public void run() {
		while (true) {
			//同步代码块
			synchronized(ob){
				if (ticket>0) {
					System.out.println(Thread.currentThread().getName()+"正在销售第"+ticket+"张票");
					ticket--;
				}else {
					System.out.println("票已经销售完毕");
					break;
				}
			}
		}
	}
}

7.2:同步方法

将要一起执行的代码放在同步方法中,同步方法每次允许一个线程进行执行,其他线程必须在外面等待,等待同步方法中线程执行,且另一个抢到cpu时间片才能 到同步方法中进去执行.

  • 1:语法:
	public synchronized void saleTicket() {
		要一起执行的代码(锁范围)
   }
  • 2:同步方法的锁范围也是越小越好.
/**
 * 任务类
 */
public class MyRunnable implements Runnable{
	public int ticket=1000;

	/**
	 * 重写任务方法
	 */
	@Override
	public void run() {
		while (true) {
			if(saleTicket()) {
				break;
			}	
		}
	}
	
	/**
	 * 同步方法
	 */
	public synchronized boolean saleTicket() {
		if (ticket>0) {
			System.out.println(Thread.currentThread().getName()+"正在销售第"+ticket+"张票");
			ticket--;
			return false;
		}else {
			System.out.println("票已经销售完毕");
			return true;
		}
	}
}

7.3:对象互斥锁

要手动上锁,还要确保在任意情况下能解锁.

  • 1:语法:
   	Lock l=new ReentrantLock();
   		l.lock();上锁
   			要一起执行的代码;(锁范围)
   		l.unLock();释放锁(解锁)
  • 2:对象互斥锁的锁范围越小越好.
  • 3:对象互斥锁一定要确保在任何情况下能解锁,否则会出现死锁现象.
/**
 * 任务类
 */
public class MyRunnable implements Runnable{
	public int ticket=1000;
	
	//创建对象互斥锁的对象
	Lock l=new ReentrantLock();
	
	/**
	 * 重写任务方法
	 */
	@Override
	public void run() {
		while (true) {
				l.lock();//上锁
				try {
					if (ticket>0) {
						System.out.println(Thread.currentThread().getName()+"正在销售第"+ticket+"张票");
						ticket--;
					}else {
						System.out.println("票已经销售完毕");
						break;
					}
				} finally {
					l.unlock();//解锁
				}
		}
	}
}

7.4:(了解)ReentrantReadWriteLock读写锁

一种支持一写多读的同步锁,读写分离,可分别分配读锁和写锁.适用于:读特别频繁时,就可以这种锁.
互斥规则:
写-写:互斥,阻塞.
读-写:互斥,阻塞.
读-读:不互斥不阻塞.

public class WriteAndReadLockTest {
//	//创建一个读写锁对象
//	ReentrantReadWriteLock rrwl=new ReentrantReadWriteLock();
//	//根据读写锁创建读的锁
//	ReadLock rl=rrwl.readLock();
//	//根据读写锁创建写的锁
//	WriteLock wl=rrwl.writeLock();
	
	Lock l=new ReentrantLock();
	//声明一个成员变量
	private int num;
	
	/**
	 * 用读取锁来获取属性值
	 * @return
	 * @throws InterruptedException 
	 */
	public int getNum() throws InterruptedException {
		//读取锁上锁
		//rl.lock();
		l.lock();
		try {
			Thread.sleep(1000);
			return num;
		} finally {
			//读取锁解锁
			//rl.unlock();
			l.unlock();
		}
	}
	
	/**
	 * 用写入锁来给属性设值
	 * @param num
	 * @throws InterruptedException 
	 */
	public void setNum(int num) throws InterruptedException {
		//读取锁上锁
		//wl.lock();
		l.lock();
		try {
			Thread.sleep(1000);
			this.num = num;
		} finally {
			//读取锁解锁
			//wl.unlock();
			l.unlock();
		}
	}
}
		
		public static void main(String[] args) {
		//创建读写锁的类的对象
		WriteAndReadLockTest warlt=new WriteAndReadLockTest();
		//创建读任务对象
		Runnable r1=new Runnable() {
			@Override
			public void run() {
				try {
					warlt.getNum();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		};
		
		//创建写的任务对象
		Runnable r2=new Runnable() {
			@Override
			public void run() {
				try {
					warlt.setNum(11);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		};
		
		
		//创建20个线程的线程池
		ExecutorService es=Executors.newFixedThreadPool(20);
		//开始时间
		Long start=System.currentTimeMillis();
		
		//拿出两个线程对象来写
		for (int i = 1; i <=2; i++) {
			es.submit(r2);
		}
		
		//拿出18个线程来读
		for (int i = 1; i <=18; i++) {
			es.submit(r1);
		}
		
		//关闭线程池
		es.shutdown();
		
		//判断线程是否关闭后执行完,再计算执行时间
		while (es.isTerminated()==false) {
			System.out.println("花费的时间:"+(System.currentTimeMillis()-start));
		}
	    }

8.线程同步

线程越安全,效率越低.
优点:安全性高
缺点:效率低(线程抢到cpu时间片,还得等待线程同步的代码中没有线程在执行,它才能进去执行)

9.(了解)线程安全的集合

有下划线的表示线程安全的集合.
在这里插入图片描述

9.1:CopyOnWriteArrayList(使用与ArrayList一样)

读不锁,写有锁,读写之间不阻塞,优于读写锁.写入时,先copy一个容器副本,再添加新元素,最后替换引用.

9.2:CopyOnWriteArraySet

底层采用CopyOnWriteArrayList实现,不同在于,使用add添加元素时会调用addIfAbsent()方法,会遍历数组,如元素存在,则不添加.

9.3:ConcurrentHashMap(使用与hashMap一样)

采用分段锁.

9.4:Queue:表示队列先进先出.

offer(E e);添加元素.
poll() ;获取第一个元素并移除.
peek();获取第一个元素但不删除.

9.5:ConcurrentLinkedQueue

线程安全,可高效读写的队列,高并发下性能最好的队列.
无锁,CAS比较交换算法

9.6:BlockingDeque

是Queue的了接口,阻塞的队列,增加了两个线程状态为无限期等待的方法.

  • 适用场景:可用于解决生产者和消费者问题.

9.7:ArrayBlockingQueue

数组结构实现,有界队列.(手工固定上限)

9.8:LinkedBlockingDeque

链表结构实现,无界队列.(默认上限是Integer.MAX_VALUE)

个人笔记，思路，仅供参考

Masol126
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python线程锁有几种锁_python线程中加锁范围是越大越好还是越小越好呢？
weixin_39796855的博客
12-17 364
把锁放在循环外面from threading import Thread, Lockimport timenum = 0def test1():global num# 上锁mutex.acquire()for i in range(1000000):num += 1# 解锁mutex.release()print("--test1--num=%d" % num)def test2():global...
synchronized和Lock的区别
That_Man_return的博客
08-04 155
synchronized 是Java 并发编程中很重要的关键字，另外一个很重要的是 volatile。Syncronized 的目的是一次只允许一个线程进入由他修饰的代码段，从而允许他们进行自我保护。Synchronized 很像生活中的锁例子，进入由Synchronized 保护的代码区首先需要获取 Synchronized 这把锁，其他线程想要执行必须进行等待。Synchronized 锁住的代码区域执行完成后需要把锁归还，也就是释放锁，这样才能够让其他线程使用。 Lock 是 Java并发编程中很重要
JavaSE--线程1
ggyggy10的博客
12-08 6239
JavaSE--线程一、线程的概念二、使用步骤1.引入库2.读入数据总结新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习
JavaSE--多线程
Zzh1110的博客
05-05 2393
文章目录1.并发与并行2.进程与线程3.线程调度4.主线程： 1.并发与并行 ●并发：指两个或多个事件在同一时间段内发生。（交替执行） ●并行：指两个或多个事件在同一时刻发生。（同时发生） 即，并发就是你洗完澡后再听歌，并行就是你一边洗澡一边听歌。 2.进程与线程 （线程<进程） ●进程：程序的执行过程。（可在任务管理器查看） ●线程：进程中的一个执行单元。 一个程序运行后至少有一个进程，一...
javase进阶 - 多线程
Hello_super的博客
11-22 314
JavaSE进阶 - 多线程 1、基本概念 什么是进程？ 进程是一个应用程序（1个进程是一个软件）。 什么是线程？ 线程是一个进程中的执行场景/执行单元，一个进程可以启动多个线程。 对于Java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后 会先启动JVM，而JVM就是一个进程，JVM在启动一个主线程调用main方法，同时在启动一个垃圾回收器线程负责看护，回收垃圾。一个是垃圾回收器线程、一个是执行main方法的主线程。 进程和线程之间是什么关系？ 阿里巴巴：进程 马云：阿
JavaSE----多线程总结
qq_45729665的博客
07-04 403
JavaSE多线程总结 1.进程与线程的定义 进程：一个应用程序。 线程：一个应用程序的执行场景或是执行单元 举例： 进程1：阿里巴巴 线程A: 马老师 线程B: 前台小姐姐 进程2：京东 线程A: 刘老师 线程B: 前台小姐姐 进程1和进程2是独立不共享的 线程1和线程2堆内存和方法区共享；栈空间独立不共享 2.实现线程的方法 编写一个类，直接继承Thread，重写run方法： //定义线程类 class MyThread extends Thread{ @Override
javaSE--多线程2
ggyggy10的博客
12-09 5832
文章目录一、线程的上下文切换1.线程切换存在的问题二、线程安全(同步)问题三、解决线程安全问题--上锁上锁的方法：1.同步方法2.同步代码块3.同步锁synchronize的基本原理锁对象乐观锁和悲观锁乐观锁总结 一、线程的上下文切换 一个CPU内核中同一时间只能运行一个线程或者一行指令，切换到另一个线程的过程称为线程的上下文切换 1.线程切换存在的问题 1.线程切换的时候如何找到上次执行的地方？ 每个线程中都有各自的程序计数器，用于记录上次执行的行数 线程在上下切换时会消耗时间，性能会降低 二、线
java多线程空间扩展_JavaSE---多线程---扩展
weixin_34231219的博客
02-26 122
1、线程的类型1.1　　用户线程 1.2　　内核线程 2、java线程java线程的创建依赖于系统内核，通过JVM调用系统库创建内核线程；内核线程与java-Thread是1:1的映射关系；3、线程池3.1　什么时候使用线程池？a,单个任务处理的时间比较短；b,需要处理的任务数量比较大； 4、多线程并发 5、多线程并发产生不安全的原因 stock原来为5；3个线程(各线程间互不可见)分别从主存中...
JavaSE基础--多线程
weixin_42022756的博客
11-23 387
涵盖了所有多线程的知识点，具体使用上还要配合算法案例进行自我学习，并多加练习才能熟练掌握，感觉光看知识点仅仅是基础中的基础！
java se项目怎么启动_JavaSE---多线程---线程的创建、启动
weixin_35192322的博客
02-26 237
1、概述1.1　　Java中使用Thread类表示线程；所有的线程对象必须是Thread类 或 其子类的实例；每条线程的作用：完成一定的任务；Java中使用run方法来封装线程执行体；1.2　　默认情况下，主线程的名字是main；创建的多条线程的名字是：Thread-0、Thread-1、Thread-2...；1.3　　创建、启动线程：1.3.1　　继承Thread类创建继承Thread类子类-...
JavaSE专题-多线程总结.doc
06-03
JavaSE专题的多线程是Java编程中至关重要的一部分，它涉及到如何在单个程序中同时执行多个任务。以下是对多线程技术的详细说明： 1. **多线程技术介绍** - **进程**：一个进程是操作系统分配给应用程序的内存空间...
JavaSE多线程
09-15
JavaSE的多线程特性是其强大的功能之一，它允许开发者编写能够同时处理多个任务的程序，从而提高程序的效率和响应性。在Java中，线程是程序执行的最小单位，而进程则是资源分配的基本单位。每个Java应用程序至少有一...
网页解析
weixin_49349430的博客
12-04 4206
在网络爬虫的系统框架中，主过程由控制，解析，资源库三部分组成。解析是负责网络爬虫的一个部分，其负责的工作主要有：下载网页的功能，对网页的文本进行处理，如过滤功能，抽取特殊HTML标签的功能，分析数据功能。 1. 网页解析： 是来自某些网站搜集来的资料，这些资料包含编号，名称，图片，链接等等元素，在这里只是将信息从标签中提取出来 获取请求返回的页面信息，筛选出我们想要的数据就可以了,有时候我们需要去一些网站上抓取数据，要想抓取数据，就必须先了解网页结构，根据具体的网页结构，编写对应的程序对数据进行采集 2.
JavaSE(五)--数组
weixin_49349430的博客
11-22 759
1.数组: 在内存内开辟一组连续空间来存值叫数组. 1.1 数组也是一种变量,也是一种引用数据类型. 1.2 数组由四个组成部分 数组名,数据类型,元素,索引(下标). 1.3 类型 同一个数组中,元素的数据类型相同的;不同的数组数据类型可以是java中任意类型. 1.4 索引 数组的索引从0开始. 1.5 访问数组中某个空间元素 数组名[索引]. 1.6 空间 数组一但分配了空间,它的长度是固定的. 1.7长度 数组的长度:数组名.length 1.8 范围 数组的索引范围在:0~数组名.lengt
SpringCloud学习之旅
weixin_49349430的博客
12-24 495
Author：Eric Version：9.0.0 文章目录一、SpringCloud介绍1.1 微服务架构1.2 SpringCloud介绍二、服务的注册与发现-Eureka【`重点`】2.1 引言2.2 Eureka的快速入门2.2.1 创建EurekaServer2.2.2 创建EurekaClient2.2.3 测试Eureka2.3 Eureka的安全性2.4 Eureka的高可用2.5 Eureka的细节三、服务间的负载均衡-Ribbon【`重点`】3.1 引言3.2 Ribbon的快速入..
JavaSE(一)--概述与环境
weixin_49349430的博客
11-21 460
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
JavaSE多线程技术详解及常见问题分析
多线程技术是一种能够在同一进程中同时执行多个线程的技术。多线程技术可以提高程序的运行效率，充分利用计算机的多核处理器，使得程序能够更加灵活地处理各种任务。在Java中，多线程技术是非常重要的，因为它可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值