Java线程深入的理解

今天来讲解下java的线程机制.废话不多说，直接上代码吧。线程实现之Runable接口，我们选择该接口比较好，实现资源的共享

/*** @author hackbase   Java多线程之Runable接口*/
public class ThreadTestDemo2 {public static void main(String[] args) {HelloWorld h1=new HelloWorld("线程A");Thread  Demo=new Thread(h1);HelloWorld h2=new HelloWorld("线程B");Thread  Demo1=new Thread(h2);Demo.start();Demo1.start();}
}class HelloWorld implements  Runnable{private  String name;/*** 添加无参数的构造方法*/public HelloWorld(){}public HelloWorld(String name){this.name=name;}@Overridepublic void run() {for(int i=0;i<5;i++){System.out.println(name+"运行了    "+i);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}

线程的休眠调用的线程的Sleep方法,比如Thread.Sleep()来实现，谁调用，谁去睡觉。来看看下面的代码.

/*** @author hackbase   下面我们来看看线程的休眠----->>>* 线程的休眠调用线程的Sleep函数来实现，谁调用，谁去睡觉.*/
public class ThreadSleepDemo {public static void main(String[] args) {ThreadSleepone he = new ThreadSleepone();Thread demo = new Thread(he, "线程A");demo.start();}
}class ThreadSleepone implements Runnable {@Overridepublic void run() {for (int i = 0; i < 3; i++) {System.out.println(Thread.currentThread().getName());try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}}
}

线程的插入使用的join方法，比如目前2个线程，分别是A,B,当我们把b线程插入到A线程之后，此时A线程就会终止.等待B线程执行完毕之后，再去执行A线程。相当于A线程执行了一半，就回去执行B线程，当B线程执行完毕后，在继续执行A线程。

下面来看看代码把。

/*** @author hackbase   将一个线程强制插入到另外的一个线程里面.*/
public class ThreadJoinDemo {public static void main(String[] args) {ThreadJoin he = new ThreadJoin();Thread Demo = new Thread(he, "线程A在运行.....");Demo.start();for (int j = 0; j < 50; j++) {if (j > 10) {try {Demo.join();//强制的执行线程A} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("main线程在执行---->>>>>>"+j);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}class ThreadJoin extends Thread {@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName());}}
}

从程序的结果我们可以看到。

线程的中断使用的就是InTerrupt函数来实现的。下面我们来看看代码把

/*** @author hackbase  线程的中断使用interrupt函数来实现.*/
public class ThreadInterrupt {public static void main(String[] args) {ThreadSlep he = new ThreadSlep();Thread demo = new Thread(he, "线程----->");demo.start();try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}demo.interrupt();//1秒后线程被中断.}
}class ThreadSlep implements Runnable {@Overridepublic void run() {System.out.println("开始执行Run方法");try {//线程开始休眠Thread.sleep(Long.parseLong("1000"));} catch (InterruptedException e) {System.out.println("线程休眠突然被中断的时候被打断");return;}System.out.println("线程正常的终止------>");}
}

获得当前线程的名字使用的就是GetName方法来实现的，下面来看看代码。

/*** @author hackbase  取得线程的名字.* 每次java程序启动的时候，都会启动两个线程，一个是main方法，所运行的线程，一个就是垃圾回收器运行线程**/
public class ThreadDemoTest5 {public static void main(String[] args) {GetThreadName h1 = new GetThreadName();new Thread(h1, "A线程").start();new Thread(h1, "B线程").start();new Thread(h1, "C线程").start();new Thread(h1).start();}
}class GetThreadName implements Runnable {@Overridepublic void run() {for (int i = 0; i < 5; i++) {System.out.println(Thread.currentThread().getName());}}
}

代码很简单，就不多解释了。

为何使用runable,而不是使用Thread类来实现了，我们来看看代码把。

/*** @author hackbase   使用Runable接口更加的容易实现资源的共享.* 实现runbale接口的好处:* 1.适合多个相同的 程序代码去处理同一资源.* 2.增加代码的健壮性，代码可以被多个线程共享.让程序和数据独立.*/
public class ThreadDemoTest4 {public static void main(String[] args) {MyThread my=new MyThread ();MyThread ts = new MyThread(my, "窗口1在售票");new Thread(my,"窗口1在售票").run();new Thread(my,"窗口2在售票").run();new Thread(my,"窗口3在售票").run();}
}class MyThread implements Runnable {private int ticket = 5;public MyThread(){}public MyThread(MyThread ts, String name) {}@Overridepublic void run() {for (int i = 0; i <= 20; i++) {if (this.ticket > 0) {System.out.println(Thread.currentThread().getName()+ "正在卖票= " +this.ticket--);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}}
}

/*** @author hackbase  关于是选择thread还是实现Runable接口了。* 来看看下面的代码。Runable更加的容易实现资源的共享.* 继承Thread不能实现资源的共享.*/
public class ThreadDemoTest3 {public static void main(String[] args) {HelloTest h1=new HelloTest();HelloTest h2=new HelloTest();HelloTest h3=new HelloTest();h1.start();h2.start();h3.start();}
}class  HelloTest extends Thread{private  int count=5;@Overridepublic void run() {//重写了run方法for(int i=0;i<7;i++){if(count>0){System.out.println("count=  "+count--);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}}
}

使用 Runable接口来实现线程，更好，建议大家使用该接口来实现java的线程.

设置线程的优先级，一般优先级越高的线程首先会获得Cpu的使用权限，但是并不一定，还是来看看代码把.

/*** @author hackbase   设置线程的 优先级，可以通过SetPriority方法来实现了。* 来看看下面的代码.* 在一般情况下，优先级越高的线程就会先执行，但是并不一定，谁先执行取决于谁先获得Cpu的资源。* 线程的礼让，可以使用yield将线程交给其他的 线程来执行------>*/
public class SetPriority {public static void main(String[] args) {Thread h1 = new Thread(new HelloWorldSetProicty(), "A");Thread h2 = new Thread(new HelloWorldSetProicty(), "B");Thread h3 = new Thread(new HelloWorldSetProicty(), "C");h1.setPriority(8);h2.setPriority(2);h3.setPriority(6);h1.start();h2.start();h3.start();}
}class HelloWorldSetProicty implements Runnable {@Overridepublic void run() {for (int i = 0; i < 5; i++) {System.out.println(Thread.currentThread().getName() + " 在运行   " + i);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}

设置守护线程，来看看代码。使用SetDemo来实现的。来看看代码.

/*** @author hackbase   今天来说说java的守护线程.正如名字所言，守护线程。。* 在java里面只要前台有一个线程在运行，整个java程序就不会消失的。所以此时可以设置一个后台的线程.* 即使这样java线程消失了，那么后台的程序依旧可以运行，这就是守护线程，还是来看看下面的代码吧* 守护线程就是前台线程可以消失。，但是后台线程可以继续运行。* 虽然是一个死循环，但是还是可以执行完毕的。因为死循环的操作线程设置为守护线程了。*/
public class SetDemoThread {public static void main(String[] args) {SetHello he = new SetHello();Thread h1 = new Thread(he, "线程");//设置守护线程.h1.setDaemon(true);h1.start();System.out.println("main线程执行完毕------>");}}class SetHello implements Runnable {@Overridepublic void run() {while (true) {System.out.println(Thread.currentThread().getName() + "守护在运行----->");}}
}

判断线程是否启动

/*** @author hackbase   isAlive判断线程是否启动.....*/
public class IsAliveDemo {public static void main(String[] args) {ActiveThread Demo1 = new ActiveThread();Thread he = new Thread(Demo1);System.out.println("线程在启动之前------>>>" + he.isAlive());he.start();System.out.println("线程在启动之后------>>>" + he.isAlive());}
}class ActiveThread extends Thread {@Overridepublic void run() {/*** 重写了run方法.*/for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName() + "正在运行......");}}
}

/*** @author hackbase Java的多线实现.*/
public class DemoTest1 {public static void main(String[] args) {ThreadTest t1 = new ThreadTest("jack");ThreadTest t2 = new ThreadTest("bill");t1.start();t2.start();}
}class ThreadTest extends Thread {private String name;public ThreadTest() {}public ThreadTest(String name) {this.name = name;}@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println(name + "运行了" + i + "次");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}

Java线程深入的理解相关推荐

对Java线程概念的理解
1.什么是线程现代操作系统在运行一个程序时, 会为其创建一个进程. 例如, 启动一个Java程序, 操作系统就会创建一个Java进程. 现代操作系统调度的最小单元是线程, 也叫轻量级进程(Light ...
黑马程序员并发编程笔记(二)--java线程基本操作和理解
3.java进程的基本操作 3.1.创建进程方法一,直接使用 Thread // 构造方法的参数是给线程指定名字,,推荐给线程起个名字(用setName()也可以) Thread t1 = new ...
java 线程池的理解_JAVA线程池原理的理解
线程池原理基础理解: 线程池初始化规定个数的线程,然后这些线程一直运行,并且监控线程队列,只要线程队列被添加进线程,那么线程池不断从队列中取出线程运行.直到队列中的线程为空.实例代码如下: packa ...
【Java线程】深入理解Volatile关键字和使用
目录背景 volatile原理 volatile特性可见性有序性原子性使用场景背景理解volatile底层原理之前,首先介绍关于缓存一致性协议的知识. 背景:计算机在执行程序时,每条指令 ...
Java线程的一点理解
1.线程和进程的区别进程是资源进行分配和调度的基本单位进程包含线程进程有自己线程cpu调度的最小单位 2.线程的生命周期一个线程被创建变成了new,在获取到除了cpu之外的资源后变成了run ...
Java线程池深入理解
最近项目中进行告警模块性能优化,不少地方使用了线程池技术,整理总结如下. package com.coshaho.threadpool;import java.util.concurrent.Bloc ...
虚拟机实现java线程_深入理解java虚拟机（23）：java与多线程
线程有以下三种实现方式 1.使用内核线程方式实现,优点内核完成线程切换和操纵调度器进行调度,并且负责将线程任务映射到处理器上.程序一般不使用内核线程会使用一种轻量级进程,轻量级进程与内核线程一对一模型 ...
Java线程中断的理解（转载）
https://blog.csdn.net/qq_41512783/article/details/108943193?utm_medium=distribute.pc_relevant.none-t ...
Java并发编程与技术内幕:线程池深入理解
林炳文Evankaka原创作品.转载请注明出处http://blog.csdn.net/evankaka 摘要: 本文主要讲了Java当中的线程池的使用方法.注意事项及其实现源码实现原理,并辅以实例加 ...

Java线程深入的理解

Java线程深入的理解相关推荐

最新文章

热门文章