Java教程

java---多线程

本文主要是介绍java---多线程,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

1.什么是进程?

   进程:在操作系统中运行的某个软件/程序

   任何软件/程序在运行中都要被加载到内存中,而内存负责运行这个软件/程序所需要的内存空         间,就被称作在内存中的一个进程

   进程需要依赖与系统

   进程就是在操作系统中动态运行的静态代码

2.什么是线程

   线程就是在操作系统中动态运行的静态代码【进程】中的某一项具体功能的执行过程【执行轨迹/执行线索】

例如:

   我们在window操作系统上打开“暴风影音”播放电影,此时“暴风影音”就会在window操作系    统中产     生一个进程;打开“暴风影音”播放电影的时候有画面,声音,中文字幕等等,这些    画面,声音,中     文字幕就是这个“暴风影音”进程中的多个线程。

3.什么是多线程

    多线程:某一个程序在运行时可能会产生多个不同的执行线索【执行轨迹】,着多个不同                    的执行线索【执行轨迹】共同运行的情况下就是多线程。

     往往我们会感觉到这些不同的执行线索【执行轨迹】同事之星,实际上这是一种错觉假         象。其 实当这些多个不同的执行线索【执行轨迹】在运行时,某一个时刻只有一个执行         线索在运行,只是这对个不同的执行线索【执行轨迹】快速切换而已

4.为什么使用多线程

   1.使用多线程的目的就是为了提高程序执行效率。

   2.解决并发问题

   3.并行和并发有什么区别

         并行:多个处理器或多核处理器同事处理多个任务

         并发:多个任务在同一个CPU核上,安细分的时间片轮流(交替)执行,从逻辑上看是那                         些任务同时执行

5.多线程的创建方式以及区别

    1.通过继承Thread类创建线程,Thread类是java提供的创建线程的类

      创建步骤:

1.创建一个类,继承Thread类

2.重写run方法

3.需要由线程执行的具体动作写入run方法

运行步骤:

  1.创建线程类对象

   2.通过线程对象调用start方法启动线程

例如:

package com.object.test1;

public class MyThread extends Thread{
	public void run() {
			for(int i=1;i<=50;i++){
				String name=Thread.currentThread().getName();
				System.out.println(name+"--i=="+i);
			}
		}
}
package com.object.test1;

public class MyMain {

	public static void main(String[] args) {
		//创建线程对象
		MyThread my=new MyThread();
		MyThread my2=new MyThread();
		//通过线程对象调用start方法启动线程
        my.start();
        my2.start();
	}

}

2.通过实现Runnable接口创建线程类

   Runnable接口---Thread类就实现过这个接口,只有一个run方法

   创建步骤:

1.创建一个类,实现Runnable接口

2.重写run方法

3.将需要由线程执行到具体动作写入run方法

运行步骤:

1.创建目标对象

2.通过Thread类的构造方法创建线程对象

3.通过线程对象调用start方法启动线程。···

例如:

package com.object.test2;

public class MyThreadClass implements Runnable{
	public void run() {
		for(int i=1;i<=50;i++){
			//得到当前正在运行的线程对象的名称
			String name=Thread.currentThread().getName();
			System.out.println(name+"--i=="+i);
		}
		
	}
}
package com.object.test2;

public class MyMain {

	public static void main(String[] args) {
		//创建目标对象
		MyThreadClass my1=new MyThreadClass();
		//创建线程对象
		Thread th1=new Thread(my1);
		Thread th2=new Thread(my1);
		//调用start方法启动线程
		th1.start();
		th2.start();
	}

}

3.通过Callable和Future接口创建线程

1.  java.util.concurrent.Callable接口--这个接口中只有一个方法call()

2.  java.util.concurrent.Future接口--有一个重要方法get()

1.public boolean cancle(boolean mayInterruptIfRunning)---是否取消正在执行的线程任务[false为取消任务]

2.public boolean isCancelled()---判断是否是线程任务没有运行结束之前取消线程

3.public  boolean isDone---判断线程任务·是否正常执行完毕

4.V    get()---得到线程任务的执行结果

3. java.util.concurrent.FutureTask类--继承了Runnable接口 

1.public boolean cancel(boolean mayInterruptIfRunning)---是否取消正在执行的线程任务

2.public boolean isCancelled()---判断是否是线程任务没有运行结束之前取消线程

3. public boolean isDone()---判断线程任务是否正常执行完毕

4.V   get()---得到线程任务的执行结果

 创建步骤:

1.创建一个类,实现Callable接口

2.重写call()方法

3.将需要由线程执行的具体动作写入call()方法

注意:实现Callable接口的时候需要指定线程执行结果的返回值类型

运行步骤:

1.创建目标对象

2.通过FutureTask类的构造方法public FutureTask(Callable<V>callable)封装目标对象为Runnable子类对象

3.通过Thread类的构造方法public Thread(Runnable runnable)创建线程对象

例如:

package com.object.test3;

import java.util.concurrent.Callable;

public class MyThread implements Callable<Integer>{
	public Integer call() throws Exception {
		int i=1;
		while(i<=50){
			//得到当前线程的名称
			String name=Thread.currentThread().getName();
			System.out.println(name+"--i=="+i);	
			i++;
		}
		return i;
	}

}

 

package com.object.test3;

import java.util.concurrent.FutureTask;

public class MyMain {

	public static void main(String[] args) {
		//创建目标对象
		MyThread my1=new MyThread();
		//通过FutureTask类的构造方法public FutureTask(Callable<V> callable)封装目标对象成Runnable子类对象
		FutureTask  ft1=new FutureTask<>(my1);
		FutureTask  ft2=new FutureTask<>(my1);
		//通过Thread类的构造方法public Thread(Runnable runnable)创建线程对象
		Thread th1=new Thread(ft1);
		Thread th2=new Thread(ft2);
		//启动线程
		th1.start();
		th2.start();
		//1. public boolean cancel(boolean mayInterruptIfRunning)是否取消正在执行的线程任务[false为取消任务]
		//ft1.cancel(true);
		//2. public boolean isCancelled()判断是否是线程任务没有运行结束之前取消线程
		//System.out.println(ft1.isCancelled());
		//3. public boolean isDone()判断线程任务是否正常执行完毕
		//System.out.println(ft1.isDone());
		//4. V get()得到线程任务的执行结果
		try{
		int in=(Integer)ft1.get();
		System.out.println("线程1的运行结果=="+in);
		}catch (Exception e) {
			e.printStackTrace();
		}
	}

}

4. 通过线程池创建多线程【使用的比较少,所以不强调】

6.多线程的创建方式的区别

   1.继承Thread类

1.创建新类继承Thread类重写run方法

2.run方法没有返回值,不能声明抛出异常

3.创建Thread类的子类对象【线程对象】,通过子类对象调用start方法启动线程

4.无法共享资源

5.不考虑资源共行时 

package com.object.test1;

public class MyThread2 extends Thread{
	int ticket=5;
	public void run() {
			boolean flag=true;
			while(flag){
				if(ticket<=0){
					flag=false;
				}else{
					String name=Thread.currentThread().getName();
					System.out.println(name+",卖出1张票,还剩"+(--ticket)+"张");
				}
			}
		}
}
package com.object.test1;

public class MyMain {

	public static void main(String[] args) {
		MyThread2 my1=new MyThread2();
		MyThread2 my2=new MyThread2();
		my1.start();
		my2.start();
	}

}

2.实现Runnable接口

1.创建新类实现Runnable接口,重写run方法

2.run方法没有返回值,不能声明抛出异常

3.创建实现Runnable接口的子类对象【目标对象】,通过Thread的的构造方法将目标对象转换成线程对象,通过线程对象调用start方法启动线程

4.可以共享资源

5.考虑资源共享时

package com.object.test2;

public class MyThreadClass2 implements Runnable{
	int ticket=5;
	public void run() {
		boolean flag=true;
		while(flag){
			if(ticket<=0){
				flag=false;
			}else{
				String name=Thread.currentThread().getName();
				System.out.println(name+",卖出一张票,还剩"+(--ticket)+"张");
			}
		}
	}
}
package com.object.test2;

public class MyMain {

	public static void main(String[] args) {
		 MyThreadClass2 my1=new  MyThreadClass2();
		 Thread th1=new Thread(my1);
		 Thread th2=new Thread(my1);
		 th1.start();
		 th2.start();
	}

}

3.Callable和Future接口

1.创建新类实现Callable接口重写call()方法,注意Callable接口的泛型类型

2.call方法有返回值,通过Future接口提供的get方法得到返回值,可以声明抛出异常

3.创建实现Callable接口的子类转换成Runnable接口类型,通过Thread的构造方法将Runnable接口类型对象转换成线程对象,通过线程对象调用start方法启动线程

4.可以资源共享

5.考虑资源共享时,异步编程  

这篇关于java---多线程的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!