文档章节

Java学习线程

o
 osc_z1hvg4cu
发布于 2018/04/24 16:29
字数 2752
阅读 14
收藏 0

精选30+云产品,助力企业轻松上云!>>>

进程:进程指正在运行的程序。确切的来说,当一个程序进入内存运行,即变成一个进程,进程是处于运行过程中的程序,并且具有一定独立功能。

线程:线程是进程中的一个执行单元,负责当前进程中程序的执行,一个进程中至少有一个线程一个进程中是可以有多个线程,这个应用程序也可以称之为多线程程序。

单线程程序:若有多个任务,只能依次执行。当上一个任务执行完毕后,才能执行下一个任务。

多线程程序:若有多个任务可以同时执行。

package com.oracle.demo01;

public class Demo01 {
	/*普通main方法的执行就叫单线程
	 * 单线程:只有一条路,后面的代码必须等着前面的代码执行完才能执行
	 * main的名字就叫主线程 "main"
	 * 
	 * 在dos窗口,执行java.demo01
	 * 启动JVM,运行demo01中的main方法
	 * JVM运行main方法的时候,去找操作系统,开线程,开一条路径
	 * 对于CPU来说,就有了一条执行路径
	 * 
	 * */
     public static void main(String[] args) {
		function();
		System.out.println(Math.abs(-9));
	}
     public static void function(){
    	 for(int i=0;i<10000;i++){
    		 System.out.println(i);
    	 }
     }
}

Thread类

构造方法:

常用方法:

Runnable接口

常用方法:

Thread类构造方法:

自定义线程的两种方式

1、将类声明为Thread类的子类,该子类应重写Thread类的run方法。

      创建对象,开启线程。run方法相当于其他线程的main方法。

2、声明一个实现Runnable接口的类,该类实现run方法。

   然后创建Runnable的子类对象,传入到某个线程的构造方法中开启线程

第一种方式:

1、 定义一个类继承Thread。

2 、重写run方法。

3 、创建子类对象,就是创建线程对象。

4 、调用start方法,开启线程并让线程执行,同时还会告诉jvm去调用run方法。

package com.oracle.demo01;

public class MyThread extends Thread {
	// 构造方法
	public MyThread() {
	}

	public MyThread(String name) {
		super(name);
	}

	@Override
	public void run() {
		Thread t = Thread.currentThread();
		String name = t.getName();// 获取当前正在执行的线程的名称
		for (int i = 0; i < 5; i++) {
			System.out.println(name + "正在运行" + i);
			try {
				t.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}
package com.oracle.demo01;

public class Demo02 {
	public static void main(String[] args) {
		//创建子类对象  就是创建线程对象
		MyThread mt = new MyThread();
	    //启动线程(隐含运行run方法)
		mt.start();
		
		MyThread mt1 = new MyThread("小猪佩奇");
		//mt1.setName("小猪佩奇");  //设置自定义线程名称,但是主线程main不能改名称
		mt1.start();
	    for(int i=0;i<5;i++){
		    System.out.println("main方法"+i);
	    }
	}
}

线程对象调用 run方法和调用start方法区别

线程对象调用run方法不开启线程。仅是对象调用方法。线程对象调用start开启线程,并让jvm调用run方法在开启的线程中执行。

继承Thread类的原理

Thread t1 = new Thread();

t1.start();//这样做没有错,但是该start调用的是Thread类中的run方法,而这个run方法没有做什么事情,更重要的是这个run方法中并没有定义我们需要让线程执行的代码。

创建线程的目的:

是为了建立程序单独的执行路径,让多部分代码实现同时执行。也就是说线程创建并执行需要给定线程要执行的任务。

对于之前所讲的主线程,它的任务定义在main函数中。自定义线程需要执行的任务都定义在run方法中。

Threadrun方法中的任务并不是我们所需要的,只有重写这个run方法。既然Thread类已经定义了线程任务的编写位置(run方法),那么只要在编写位置(run方法)中定义任务代码即可。所以进行了重写run方法动作。

第二种方式:

1、定义类实现Runnable接口。

2、覆盖接口中的run方法。。

3、创建Thread类的对象

4、将Runnable接口的子类对象作为参数传递给Thread类的构造函数。

5、调用Thread类的start方法开启线程。

package com.oracle.demo01;

public class RunnableDemo implements Runnable{

	@Override
	public void run() {
		for(int i=0;i<5;i++){
			System.out.println("线程正在执行"+i);
		}	
	}
}

package com.oracle.demo01;

public class Test {
	public static void main(String[] args) {
        //创建Runnable的子类对象
	RunnableDemo rd=new RunnableDemo();
	//创建Thread类对象,并将Runnable的子类对象作为参数传递给Thread类的构造方法
         Thread t=new Thread(rd);
         t.start();
         for(int i=0;i<5;i++){
             System.out.println("主方法正在执行"+i);
         }
	}
}

实现Runnable的原理 

       实现Runnable接口避免了继承Thread类的单继承局限性。覆盖Runnable接口中的run方法,将线程任务代码定义到run方法中。

    创建Thread类的对象只有创建Thread类的对象才可以创建线程。线程任务已被封装到Runnable接口的run方法中,而这个run方法所属于Runnable接口的子类对象,所以将这个子类对象作为参数传递给Thread的构造函数,这样,线程对象创建时就可以明确要运行的线程的任务。

实现Runnable的好处

    第二种方式实现Runnable接口避免了单继承的局限性,所以较为常用。实现Runnable接口的方式,更加的符合面向对象,线程分为两部分,一部分线程对象,一部分线程任务。继承Thread类,线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象,既是线程对象,又有线程任务。实现Runnable接口,将线程任务单独分离出来封装成对象,类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。

获取线程名称

Thread.currentThread()获取当前线程对象

Thread.currentThread().getName();获取当前线程对象的名称

线程的匿名内部类

package com.oracle.demo01;
/*
 * 匿名内部类格式:
 * new 父类或接口{
 *    重写后的抽象方法
 * }.方法
 * new Thread(){
 *    public void run(){
 *    
 *    }
 * }.start();
 * */
public class Demo03 {
    public static void main(String[] args) {
		new Thread(){
			public void run(){
				System.out.println(super.getName()+"正在运行");
			}
		}.start();
		
		new Thread(new Runnable(){
			public void run(){
				System.out.println("Runnable正在运行");
			}
		}).start();
	}
}

线程的生命周期

线程最初被创建是新建状态,通过调用start()方法到达运行状态Runnable,当run()方法结束后,线程就到了死亡状态terminated
如果在调用start()方法时,CPU没有时间或者遇到同步锁,则线程达到受阻塞状态。当CPU有时间了,线程就会从受阻塞状态到达运行状态
最后到达死亡状态。
若在运行状态,别的线程抢走了CPU资源,则线程会处于受阻塞状态;若是调用了sleep()方法,线程就会处于休眠状态,当CPU有空了,线程会重新处于运行状态;
若是调用了wait()方法,则线程处于等待状态,当调用notify()方法时或者CPU有时间了,线程会从等待状态转为运行状态。
当线程处于休眠状态或者等待状态时,若是CPU没有时间,则线程都会处于受阻塞状态。
注:在受阻塞状态:线程具有cpu执行的资格,cpu有空就执行
在休眠状态或者等待状态,线程放弃CPU的执行资格,CPU有空了线程也不执行。

线程池

线程池,其实就是一个容纳多个线程的容器,其中的线程可以反复使用,省去了频繁创建线程对象的操作,无需反复创建线程而消耗过多资源

 线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重复使用线程,线程创建的开销就被分摊到了多个任务上了,而且由于在请求到达时线程已经存在,所以消除了线程创建所带来的延迟。这样,就可以立即为请求服务,使用应用程序响应更快。另外,通过适当的调整线程中的线程数目可以防止出现资源不足的情况

使用线程池的方式—Runnable接口

线程池都是通过线程池工厂创建,再调用线程池中的方法获取线程,再通过线程去执行任务方法。

Executors:线程池创建工厂类

 public static ExecutorService newFixedThreadPool(int nThreads):返回线程池对象

 ExecutorService:线程池类

 Future<?> submit(Runnable task):获取线程池中的某一个线程对象,并执行

 Future接口:用来记录线程任务执行完毕后产生的结果。线程池创建与使用 

使用线程池中线程对象的步骤:

1、创建线程池对象

2、创建Runnable接口子类对象

3、提交Runnable接口子类对象

4、关闭线程池

package com.oracle.demo02;

public class RunnableImp implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<5;i++){
		   System.out.println(Thread.currentThread().getName()+"线程"+i);
		}
	}

}
package com.oracle.demo02;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {
	public static void main(String[] args) {
		//创建一个线程池对象,通过线程池工厂类调用newFixedThreadPool()
		//创建了盛有两个线程的线程池对象
		ExecutorService es = Executors.newFixedThreadPool(5);
		//获取线程池中某一线程对象,并执行
		es.submit(new RunnableImp());
		es.submit(new RunnableImp());
		es.submit(new RunnableImp());
                //关闭线程池
		es.shutdown();
	}
}

使用线程池方式-Callable接口

 Callable接口:与Runnable接口功能相似,用来指定线程的任务。其中的call()方法,用来返回线程任务执行完毕后的结果,call方法可抛出异常

 ExecutorService:线程池类

 <T> Future<T> submit(Callable<T> task):获取线程池中的某一个线程对象,并执行线程中的call()方法

 Future接口:用来记录线程任务执行完毕后产生的结果。线程池创建与使用 

 使用线程池中线程对象的步骤:

1、创建线程池对象

2、创建Callable接口子类对象

3、提交Callable接口子类对象

4、关闭线程池

package com.oracle.demo02;

import java.util.concurrent.Callable;

public class CallableImp implements Callable<String>{

	@Override
	public String call() throws Exception {
		// TODO Auto-generated method stub
		return "asd";
	}

}
package com.oracle.demo02;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Test2 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		// 创建线程池对象
		ExecutorService es = Executors.newFixedThreadPool(2);
		//获取线程池中的某一个线程对象,并执行线程中的call()方法
		//Future接口:用来记录线程任务执行完毕后产生的结果。线程池创建与使用
		Future<String> f = es.submit(new CallableImp());
                System.out.println(f.get());
	}
}

练习:计算1-100和1-200的总和

package com.oracle.demo02;

import java.util.concurrent.Callable;

public class CallableDemo implements Callable<Integer> {
	private int x;

	public CallableDemo(int x) {
		this.x = x;
	}

	public Integer call() throws Exception {
		int sum = 0;
		for (int i = 1; i <= x; i++) {
			sum = sum + i;
		}
		return sum;
	}

}
package com.oracle.demo02;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Test3 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		// 创建线程池对象
		ExecutorService es = Executors.newFixedThreadPool(2);
		Future<Integer> f = es.submit(new CallableDemo(100));
		Future<Integer> f2 = es.submit(new CallableDemo(200));
		System.out.println(f.get());
		System.out.println(f2.get());
		es.shutdown();
	}
}

  

上一篇: LWIP的移植
下一篇: mintUI之swipert填坑
o
粉丝 0
博文 500
码字总数 0
作品 0
私信 提问
加载中
请先登录后再评论。
Java线程与多线程教程

Java线程是执行某些任务的轻量级进程。Java通过Thread类提供多线程支持,应用可以创建并发执行的多个线程。 应用中有两类线程——用户线程和守护线程。当启动应用时,main线程是创建的第一个...

LCZ777
2014/03/25
47
0
ThreadLocal使用和原理简析

解决共享资源冲突   对于并发工作,需要某种方式来防止两个任务同时访问相同的资源,至少在关键阶段不能出现这种冲突情况。   方法之一就是当资源被一个任务使用时,在其上加锁。第一个访...

osc_gu9d45li
2019/04/15
6
0
面试官: 谈谈什么是守护线程以及作用 ?

文章首发自微信公众号: 小哈学Java 个人网站: https://www.exception.site/java-concurrency/java-concurrency-daemon-thread 目录 一、什么是守护线程 二、守护线程的作用及应用场景 三、总...

osc_msepeizi
04/16
27
0
好程序员Java分享JVM结构

  好程序员Java分享JVM结构,jvm的基本结构,也就是我们俗称概述。内容很多,而且概念量也很大,关于概念方面,让概念在你的脑子里变成图形,所以只要你有耐心、仔细,发挥自己的想象力,会...

osc_fmelmp0t
2019/05/31
2
0
好程序员Java学习路线分享MyBatis之线程优化

  好程序员Java学习路线分享MyBatis之线程优化,我们的项目存在大量用户同时访问的情况,那么就会出现大量线程并发访问数据库,这样会带来线程同步问题,本章我们将讨论MyBatis的线程同步问...

好程序员官方
2019/09/19
10
0

没有更多内容

加载失败,请刷新页面

加载更多

JIT的Profile神器JITWatch

点击上方的蓝字关注我吧 程序那些事 简介 老是使用命令行工具在现代化社会好像已经跟不上节奏了,尤其是在做JIT分析时,使用LogCompilation输出的日志实在是太大了,让人望而生畏。有没有什么...

flydean
07/04
0
0
运维基础--虚拟机的使用(一)

虚拟机的使用 开始使用Linux操作系统时,首先可能会接触到两个主要的界面:GUI和CLI,即图形界面个命令界面,而运维一般极少使用到图形界面。 一、命令提示符的格式:[root@mylab11~] # roo...

osc_9os5791s
刚刚
0
0
以程序员的方式,尽绵薄之力

作为程序员,我们不能冲在第一线,参与病毒防疫工作,我们希望通过我们的方式,让更多的人获取到关于疫情的有用的消息,正确的消息 虽然github可能是个相对小众的平台,对于非程序员来说,可...

Jipson
01/26
0
0
Oracle 等待事件之 db file scattered read

db file scattered read 官网解释: This event signifies that the user process is reading buffers into the SGA buffer cache and is waiting for a physical I/O call to return. A db......

osc_qlj7m2h9
1分钟前
0
0
互联网+时代的畅想

封面的台风卫星照片,我认为很形象地可以看作互联网的那一波浪潮。在智能手机普及的初始阶段,还记得我们对于互联网的狂热,有人说要用互联网颠覆一切,亦有人要用互联网干一切事情,当然,这...

zd200572
2015/09/02
0
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部