多线程实现原理并发机制 博客分类: java
程序员文章站
2024-03-13 19:10:27
...
进程:
查询百度大致可以理解为一段具有独立功能的程序,线程是程序中每个部分的代码,一个进程,拥有多个线程,或者子进程。windows 下exe程序就是一个进程。
线程:
线程是进程在相同时间分个每个客户单独运行的一段相同程序代码,多线程指的是在程序中同时运行的多个方法片段。
多线程的理解:
一个类如果实现了Runnable接口或者继承了Thread类,那么它就是一个多线程类,如果是要实现多线程,还需要重写run()方法,所以run() 方法是多线程的入口
但是在启动多线程的时候,不是从run()方法开始的,而是从start()开始的 理由是:当执行多线程的时候,每一个线程会抢占资源,而操作系统会为其分配资源,在start()方法中不仅执行了多线程的代码,除此还调用了一个start0()方法,该方法的声明是native,在Java语言中用一种技术叫做JNI,即JavaNativeInterface,该技术特点是使用Java调用本机操作系统提供的函数,但是有一个缺点是不能离开特定的操作系统,如果线程需要执行,必须有操作系统去分配资源,所以此操作主要是JVM根据不同的操作系统来实现的
如果多线程是通过实现Runnable接口来实现的,那么与通过继承Thread来实现有一个区别,那就是多线程的启动方式——必须是通过start()来启动,但是Runnable接口只有一个方法,并没有start()方法,所以在启动多线程的时候必须调用Thread类的一个构造方法——Thread(Runnable target),该构造方法得到了Runnable接口的一个实现,于是就可以调用Thread类的start()方法了。
线程的实现方式:大致3种
三种方式比较:
1.Thread是Runnable接口的子类,实现Runnable接口的方式解决了Java单继承的局限
2.Runnable接口实现多线程比继承Thread类更加能描述数据共享的概念
3.ThreadCallable需要执行线程时候返回值得时候可以通过这种方式。
目前代码中最好的是实现runnable接口
线程的状态以及运行过程:大致有5种
1 创建状态: 准备好一个多线程对象 new thread
2 就绪状态: 调用了start()方法,等待cpu进行调度,分配资源
3 运行状态: 执行run方法,执行线程完成方法任务。
4 阻塞状态: 暂停执行,可能将资源交给其他线程使用
5 终止状态: 线程销毁
线程的常用方法
1 取得线程的名称 getName()
2 取得当前线程对象 currentThread()
3 判断线程是否启动 isAlive()
4 线程强行运行 join()
5 线程休眠 sleep()
6 线程的礼让 yield()
7 线程挂起 suspend()
8 线程恢复 resume()
9 线程等待wait()
10 stop()停止线程
一般来说后面不怎么使用,容易造成死锁
线程的优先级 能够帮助当前线程首先抢到cpu资源,但不一定每一次一定抢的到,就是第一个运行。
static intMAX_PRIORITY 线程可以具有的最高优先级。默认10
static intMIN_PRIORITY 线程可以具有的最低优先级。默认1
static intNORM_PRIORITY 分配给线程的默认优先级。默认5
同步与死锁:
1 同步代码块 在代码块上加上synchronized 关键字,此代码块就成为同步代码块
2 同步代码块格式
synchronized(同步对象){
需要同步代码块
}
3 同步的方法 除了代码块可以同步,方法也可以同步。
4 同步方法的格式
synchronized void 方法名称(){}
查询百度大致可以理解为一段具有独立功能的程序,线程是程序中每个部分的代码,一个进程,拥有多个线程,或者子进程。windows 下exe程序就是一个进程。
线程:
线程是进程在相同时间分个每个客户单独运行的一段相同程序代码,多线程指的是在程序中同时运行的多个方法片段。
多线程的理解:
一个类如果实现了Runnable接口或者继承了Thread类,那么它就是一个多线程类,如果是要实现多线程,还需要重写run()方法,所以run() 方法是多线程的入口
但是在启动多线程的时候,不是从run()方法开始的,而是从start()开始的 理由是:当执行多线程的时候,每一个线程会抢占资源,而操作系统会为其分配资源,在start()方法中不仅执行了多线程的代码,除此还调用了一个start0()方法,该方法的声明是native,在Java语言中用一种技术叫做JNI,即JavaNativeInterface,该技术特点是使用Java调用本机操作系统提供的函数,但是有一个缺点是不能离开特定的操作系统,如果线程需要执行,必须有操作系统去分配资源,所以此操作主要是JVM根据不同的操作系统来实现的
如果多线程是通过实现Runnable接口来实现的,那么与通过继承Thread来实现有一个区别,那就是多线程的启动方式——必须是通过start()来启动,但是Runnable接口只有一个方法,并没有start()方法,所以在启动多线程的时候必须调用Thread类的一个构造方法——Thread(Runnable target),该构造方法得到了Runnable接口的一个实现,于是就可以调用Thread类的start()方法了。
线程的实现方式:大致3种
1第一种继承thread: package com.zk.study.thread; public class ThreadTest extends Thread { private String name; public ThreadTest() { super(); } public ThreadTest(String name) { super(); this.name = name; } @Override public void run() { for(int i=0;i<20;i++){ System.out.println(name+":"+i); } } } 2第二种实现runnable接口 package com.zk.study.thread; public class ThreadsconedTest implements Runnable{ private String name; @Override public void run() { for(int i=0;i<20;i++){ System.out.println(name+":"+i); } } public ThreadsconedTest() { super(); } public ThreadsconedTest(String name) { super(); this.name = name; } } 3 第三种 实现Callable package com.zk.study.thread; import java.util.concurrent.Callable; public class ThreadCallable implements Callable<String> { private String name; public ThreadCallable(String name) { super(); this.name = name; } public ThreadCallable() { } @Override public String call() throws Exception { for(int i=0;i<=30;i++){ System.out.println(name+":"+i); if(i==20){ break; } } return "执行够了,不想执行了"+name; } } 主方法,调用线程: package com.zk.study.thread; import java.util.concurrent.FutureTask; public class ThreadDemo { /** * @param args * 线程执行不是通过run方法而是同start方法,run方法是多线程的入口。 */ /*public static void main(String[] args) { ThreadTest threadA = new ThreadTest("a"); ThreadTest threadb = new ThreadTest("b"); threadA.run(); threadb.run(); }*/ /** * 第一种线程实现方式实现并发机制 b:10 a:17 b:11 a:18 * @param args */ /*public static void main(String[] args) { ThreadTest threadA = new ThreadTest("a"); ThreadTest threadb = new ThreadTest("b"); threadA.start(); threadb.start(); } */ /** * 第2种实现runable 多线程并发机制 * B:18 A:17 B:19 A:18 A:19 * @param args */ /*public static void main(String[] args) { ThreadsconedTest test1 = new ThreadsconedTest("A"); ThreadsconedTest test2 = new ThreadsconedTest("B"); Thread t1 = new Thread(test1); Thread t2 = new Thread(test2); t1.start(); t2.start(); } */ /** * 实现callable 当我需要执行到某一个时候需要一些返回值得时候 * @param args * * 打印结果 A:19 B:19 A:20 B:20 执行够了,不想执行了A 执行够了,不想执行了B */ public static void main(String[] args) { String threadName = null; ThreadCallable a= new ThreadCallable("A"); ThreadCallable b = new ThreadCallable("B"); FutureTask<String> futureTaska = new FutureTask<String>(a); FutureTask<String> futureTaskb = new FutureTask<String>(b); Thread t1 = new Thread(futureTaska); Thread t2 = new Thread(futureTaskb); t1.start(); t2.start(); try{ threadName = futureTaska.get();//通过get方法可以获取我们想要的返回值 System.out.println(threadName); threadName = futureTaskb.get(); System.out.println(threadName); }catch(Exception e){ e.printStackTrace(); } } }
三种方式比较:
1.Thread是Runnable接口的子类,实现Runnable接口的方式解决了Java单继承的局限
2.Runnable接口实现多线程比继承Thread类更加能描述数据共享的概念
3.ThreadCallable需要执行线程时候返回值得时候可以通过这种方式。
目前代码中最好的是实现runnable接口
线程的状态以及运行过程:大致有5种
1 创建状态: 准备好一个多线程对象 new thread
2 就绪状态: 调用了start()方法,等待cpu进行调度,分配资源
3 运行状态: 执行run方法,执行线程完成方法任务。
4 阻塞状态: 暂停执行,可能将资源交给其他线程使用
5 终止状态: 线程销毁
线程的常用方法
1 取得线程的名称 getName()
2 取得当前线程对象 currentThread()
3 判断线程是否启动 isAlive()
4 线程强行运行 join()
5 线程休眠 sleep()
6 线程的礼让 yield()
7 线程挂起 suspend()
8 线程恢复 resume()
9 线程等待wait()
10 stop()停止线程
一般来说后面不怎么使用,容易造成死锁
package com.zk.study.thread; class RunnableDemo implements Runnable{ private String name; public RunnableDemo(String name) { super(); this.name = name; } @Override public void run() { for(int i=0;i<20;i++){ //System.out.println("当前线程对象:"+Thread.currentThread().getName());//当前线程名字 /*try { Thread.sleep(1000);//沉睡一秒 , } catch (InterruptedException e) { e.printStackTrace(); }*/ if(i==10){ System.out.println("礼让");/** *a:8 a:9 礼让 true b:0 b:1 */ Thread.yield();//当一个线程执行到时候,礼让另外一个线程执行。 } System.out.println(name+":"+i); } } } public class ThreadCommonMethod { /** * 当前线程对象:Thread-1 当前线程对象:Thread-0 当前线程对象:Thread-1 当前线程对象:Thread-0 当前线程对象:Thread-1 当前线程对象:Thread-1 * @param args */ public static void main(String[] args) { RunnableDemo runnableDemo = new RunnableDemo("a"); RunnableDemo runnableDem01 = new RunnableDemo("b"); Thread thread = new Thread(runnableDemo); Thread thread1 = new Thread(runnableDem01); System.out.println(thread.isAlive());// 是否执行当中 false thread.start(); thread1.start(); System.out.println(thread.isAlive());//true /*for(int i=0;i<=20;i++){ if(i>10){ try { thread.join();// 强制执行线程thread // 当主线程执行到大于10的时候强制执行我们的线程,等我们线程执行完在执行主线程 } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("主线程:"+i); }*/ } }
线程的优先级 能够帮助当前线程首先抢到cpu资源,但不一定每一次一定抢的到,就是第一个运行。
static intMAX_PRIORITY 线程可以具有的最高优先级。默认10
static intMIN_PRIORITY 线程可以具有的最低优先级。默认1
static intNORM_PRIORITY 分配给线程的默认优先级。默认5
同步与死锁:
1 同步代码块 在代码块上加上synchronized 关键字,此代码块就成为同步代码块
2 同步代码块格式
synchronized(同步对象){
需要同步代码块
}
3 同步的方法 除了代码块可以同步,方法也可以同步。
4 同步方法的格式
synchronized void 方法名称(){}
package com.zk.study.thread; public class ThreadSynchronized implements Runnable { private int ticket =5; /** * @param args */ public static void main(String[] args) { ThreadSynchronized threadSynchronized =new ThreadSynchronized(); Thread thread1 = new Thread(threadSynchronized); Thread thread2 = new Thread(threadSynchronized); Thread thread3 = new Thread(threadSynchronized); thread1.start(); thread2.start(); thread3.start(); } @Override public void run() { for(int i=0;i<=10;i++){ /*synchronized (this) {//同步代码块车票:5 车票:4 车票:3 车票:2 车票:1 if(ticket>0){ try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("车票:"+ ticket--);//如果不加同步 就会出现负1 车票:0 车票:-1。资源无法共享,这时候就需要加同步。 } }*/ tell(); } } /** * 同步方法的执行 5 车票:4 车票:3 车票:2 车票:1 */ public synchronized void tell(){ if(ticket>0){ try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("车票:"+ ticket--);//如果不加同步 就会出现负1 车票:0 车票:-1。资源无法共享,这时候就需要加同步。 } } }
推荐阅读
-
多线程实现原理并发机制 博客分类: java
-
Java多线程之异步Future机制的原理和实现
-
JAVA进阶----ThreadPoolExecutor机制 博客分类: JAVA进阶java-多线程框架 javaExecutors并发线程池ThreadPoolExecutor
-
java实现简单的窗体和密码验证(传参,事件机制和事件监听的作用过程) 博客分类: java图形界面基础,事件机制 javaJFrame监听器事件机制
-
Java并发锁机制 博客分类: java Java并发锁多线程读写锁
-
HashMap和ConcurrentHashMap的实现原理和冲突解决 博客分类: java
-
Set是如何实现"没有重复元素" - hashCode compareTo equals 博客分类: JDK Java多线程
-
Set是如何实现"没有重复元素" - hashCode compareTo equals 博客分类: JDK Java多线程
-
java多线程知识整理 博客分类: Java 多线程java并发java同步控制
-
Java事件处理机制- 事件监听器的四种实现方式 博客分类: J2SE学习 JavaSwingGmailCC++