java线程基础概念

最新推荐文章于 2022-04-20 09:55:48 发布
最新推荐文章于 2022-04-20 09:55:48 发布
阅读量407 收藏
点赞数
分类专栏： java 文章标签： 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heart_1014/article/details/52078237
版权

1、线程的概念：


2、多线程的概念：

3、多线程的优点：

1）使用的系统资源最少

2）提升了性能

3）简化了程序结构

4、多线程的缺点：

1）竞争情况

2）死锁情况

3）锁饥饿

5、Thread类

用法参考代码：

public class FirstThread {
	public static void main(String[] args) throws InterruptedException {
		//获取当前java程序所在的线程
		Thread th=Thread.currentThread();
		System.out.println("当前线程："+th);//输出：当前线程：Thread[main,5,main]
		System.out.println("线程的名称："+th.getName());
		th.setName("主线程");//设置线程名称
		System.out.println("修改之后的线程名称："+th.getName());
		System.out.println("线程优先级："+th.getPriority());
		<span style="color:#FF0000;">th.setPriority(10);//设置线程优先级1-10
		th.setPriority(th.MAX_PRIORITY);//最大优先级10
		th.setPriority(th.MIN_PRIORITY);//最小优先级1
		th.setPriority(th.NORM_PRIORITY);//默认优先级5
		//非1-10的优先级则会抛出异常： java.lang.IllegalArgumentException</span>
		th.setPriority(11);
		System.out.println("修改之后的线程优先级："+th.getPriority());
		System.out.println("当前线程："+th);//输出当前线程：Thread[主线程,10,main]
		th.sleep(1000);				
	}
}

6、线程的生命周期，包含以下几个状态：

1）新建状态：创建线程Thread类实例后，进入新建状态

2）可运行状态：当start()方法被调用时，进入可运行状态

       start()用于启动线程，为线程分配系统资源，然后传到run()方法

        run()方法是线程的主方法

3）不可运行状态，以下几种情况会触发：

       休眠 sleep()

       等待 wait()

       被其他线程终止

4）终止或死亡（不能重启已终止的线程），以下几种情况会触发：

       run()方法里面代码执行完毕，正常死亡

       stop()方法终止线程

生命周期间的流转：


7、创建单线程，有以下几种方式：

1）继承Thread类（实现了Runnable接口），步骤：

      a）定义类继承：public class MyThread extends Thread

      b）重写run方法：public void run()

      c）创建线程类：MyThread t=new MyThread();

      d） 启动线程：t.start()

代码如下：

public class MyThread extends Thread{
	JFrame jf;
	JTextField tf;
	JLabel l;
	JPanel jp;
	//重写Thread的run方法
	public void run(){//写线程执行的任务
		jf=new JFrame("倒计时程序");
		jp=new JPanel();
		l=new JLabel("");
		tf=new JTextField();
		tf.setEnabled(false);//设置文本框不可以输入		
		Font f=new Font("宋体",10,18);//创建字体
		tf.setBounds(50,10,20,100);
		tf.setFont(f);
		tf.setBackground(Color.BLACK);
		jp.setBackground(Color.blue);
		jf.add(jp);
		jp.add(tf);
		jp.add(l);
		jf.setVisible(true);
		jf.setSize(300,100);
		jf.setResizable(false);//设置不可改变大小
		for(int i=60;i>0;i--){
			try {
				Thread.sleep(1000);
				tf.setText("倒计时"+i+"秒");
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}			
		}
		JOptionPane.showMessageDialog(jf, "时间到，游戏结束");
		tf.setText("");
	}
	public static void main(String[] args) {
		MyThread t=new MyThread();
		t.start();//只有调用start()方法才会执行run方法里面的内容
	}
}
2）实现Runnable接口（只有一个抽象方法run()），步骤：

      a）定义类实现Runnable接口：public class MyRunnable implements Runnable

      b）重写run方法：public void run()

      c）创建实现了Runnable接口类的实例：MyRunnable  t=new MyRunnable();

      d）创建线程类的实例，传入r：Thread t=new Thread(r);

      e） 启动线程：t.start()

代码如下： 

public class MyRunnable implements Runnable{
	JFrame jf;
	JTextField tf;
	JLabel l;
	JPanel jp;
	@Override
	public void run() {
		jf=new JFrame("倒计时程序");
		jp=new JPanel();
		l=new JLabel("");
		tf=new JTextField();
		tf.setEnabled(false);//设置文本框不可以输入		
		Font f=new Font("宋体",10,18);//创建字体
		tf.setBounds(50,10,20,100);
		tf.setFont(f);
		tf.setBackground(Color.BLACK);
		jp.setBackground(Color.blue);
		jf.add(jp);
		jp.add(tf);
		jp.add(l);
		jf.setVisible(true);
		jf.setSize(300,100);
		jf.setResizable(false);//设置不可改变大小
		for(int i=60;i>0;i--){
			try {
				Thread.sleep(1000);
				tf.setText("倒计时"+i+"秒");
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}			
		}
		JOptionPane.showMessageDialog(jf, "时间到，游戏结束");
		tf.setText("");		
	}
	public static void main(String[] args) {
		//1.创建实现了Runnable接口类的实例
		MyRunnable r=new MyRunnable();
		//2.创建线程类的实例，传入r
		Thread t=new Thread(r);
		t.start();
	}
}
8、创建多线程 

public class Race extends Thread{
	String ThreadName;//线程名称
	JFrame jf;
	JLabel l;
	JPanel jp1,jp2,jp3;//三个矩形
	public Race(){//绘制界面
		jf=new JFrame("多线程 矩形赛跑");
		jf.setVisible(true);
		jf.setSize(400,200);
		jf.setLayout(null);
		l=new JLabel("");
		l.setBounds(10, 10, 400, 200);
		jf.add(l);
     	jp1=new JPanel();
     	jp1.setSize(20,20);
     	jp1.setBackground(Color.blue);
     	jp1.setBounds(10, 40, 20, 20);
     	jf.add(jp1);
		jp2=new JPanel();
		jp3=new JPanel();
     	jp2.setSize(20,20);
     	jp2.setBackground(Color.green);
     	jp2.setBounds(10, 80, 20, 20);
     	jf.add(jp2);
     	jp3.setSize(20,20);
     	jp3.setBackground(Color.yellow);
     	jp3.setBounds(10, 120, 20, 20);
     	jf.add(jp3);

	}
	public void run(){
		try {//添加判断：如果是第2个线程，执行runb，第2个线程，执行rung，第3个线程，执行runy
			if(Thread.currentThread().getName().equals("tb")){
				runb();
			}else if(Thread.currentThread().getName().equals("tg")){
				rung();
			}else if(Thread.currentThread().getName().equals("ty")){
				runy();
			}								
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	//分别控制3个矩形X坐标的速度不同
	public void runb() throws InterruptedException{
		Random r=new Random();
		int s=r.nextInt(180);//随机y坐标,显示高度
		for(int i=0;i<=400;i+=10){
			jp1.setBounds(i,s,20,20);
			Thread.sleep(100);
		}		
	}
	public void rung() throws InterruptedException{
		for(int i=0;i<=400;i+=5){
			jp2.setBounds(i,80,20,20);
			Thread.sleep(100);
		}			
	}
	public void runy() throws InterruptedException{
		for(int i=0;i<=400;i+=16){
			jp3.setBounds(i,120,20,20);
			Thread.sleep(100);
		}			
	}
	public static void main(String[] args) {
		Race r=new Race();
		Thread tb=new Thread(r);
		tb.setName("tb");
		Thread tg=new Thread(r);
		tg.setName("tg");
		Thread ty=new Thread(r);
		ty.setName("ty");
		tb.start();  tg.start(); ty.start();		
	}
}
9、线程的特殊方法

1）isAlive 判断线程的状态

public class IsAliveDemo {
	public static void main(String[] args) {
		MyThread myThread = new MyThread();// 调用苟照，同时创建线程
		System.out.println(myThread.t + "是否还活着" + myThread.t.isAlive());
		for (int i = 1; i <= 5; i++) {
			System.out.println("主线程LOOP:" + i);
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				System.out.println("主线程已被中断");
				System.out.println(myThread.t + "是否还活着" + myThread.t.isAlive());
				System.out.println("主线程终止");
				e.printStackTrace();
			}
		}
	}
}
class MyThread implements Runnable {
	Thread t;

	public MyThread() {
		t = new Thread(this, "子线程");
		System.out.println("当前线程是：" + t);
		t.start();
	}
	@Override
	public void run() {
		for (int i = 1; i <= 5; i++) {
			System.out.println(t + "LOOP:" + i);
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				System.out.println(t + "已被中断");
				e.printStackTrace();
			}
		}
	}
}

运行结果：

当前线程是：Thread[子线程,5,main]
Thread[子线程,5,main]是否还活着true
主线程LOOP:1
Thread[子线程,5,main]LOOP:1
主线程LOOP:2
主线程LOOP:3
Thread[子线程,5,main]LOOP:2
主线程LOOP:4
主线程LOOP:5
Thread[子线程,5,main]LOOP:3
Thread[子线程,5,main]LOOP:4
Thread[子线程,5,main]LOOP:5
2）join方法： 允许线程等待，直到调用该方法的线程终止为止

用法参考代码：

public class jojnDemo {
	public static void main(String[] args) throws InterruptedException {
		MyThread myThread = new MyThread();// 调用苟照，同时创建线程
		System.out.println(myThread.t + "是否还活着" + myThread.t.isAlive());		
		try {
			myThread.t.join();//主线程等待子程序执行结束
			System.out.println("主线程开始执行");
			} catch (InterruptedException e) {
				System.out.println(myThread.t + "是否还活着" + myThread.t.isAlive());
				e.printStackTrace();
			}
		}
}
class MyThread implements Runnable {
	Thread t;

	public MyThread() {
		t = new Thread(this, "子线程");
		System.out.println("当前线程是：" + t);
		t.start();
	}
	@Override
	public void run() {
		for (int i = 1; i <= 5; i++) {
			System.out.println(t + "LOOP:" + i);
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				System.out.println(t + "已被中断");
				e.printStackTrace();
			}
		}
	}
}
运行结果： 
当前线程是：Thread[子线程,5,main]
Thread[子线程,5,main]是否还活着true
Thread[子线程,5,main]LOOP:1
Thread[子线程,5,main]LOOP:2
Thread[子线程,5,main]LOOP:3
Thread[子线程,5,main]LOOP:4
Thread[子线程,5,main]LOOP:5
主线程开始执行

使用线程实现红绿灯的例子：

import java.awt.Color;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
public class SignalDemo extends JFrame implements Runnable {
	JPanel red, yellow, green;
	JLabel time, show;
	public SignalDemo() {
		getContentPane().setBackground(Color.black);
		setSize(100, 250);
		setVisible(true);
		setLocationRelativeTo(null);
		setLayout(null);
		red = new JPanel();
		red.setBackground(Color.red);
		red.setBounds(40, 20, 40, 40);
		yellow = new JPanel();
		yellow.setBackground(Color.yellow);
		yellow.setBounds(40, 70, 40, 40);
		green = new JPanel();
		green.setBackground(Color.green);
		green.setBounds(40, 120, 40, 40);
		add(red);
		add(yellow);
		add(green);

		time = new JLabel("剩余时间:");
		time.setForeground(Color.white);
		time.setBounds(40, 170, 100, 40);
		add(time);
		show = new JLabel("");
		show.setForeground(Color.white);
		show.setBounds(95, 170, 100, 40);
		add(show);
	}

	public static void main(String[] args) {
		SignalDemo s = new SignalDemo();
		Thread t = new Thread(s);
		t.start();
	}
	@Override
	public void run() {
		try {
			while (true) {
				// 红灯亮
				red.setBackground(Color.red);
				yellow.setBackground(Color.gray);
				green.setBackground(Color.gray);
				for (int i = 3; i > 0; i--) {
					show.setText(String.valueOf(i));
					Thread.sleep(1000);
				}
				// 绿灯亮
				red.setBackground(Color.gray);
				yellow.setBackground(Color.gray);
				green.setBackground(Color.green);
				for (int i = 5; i > 0; i--) {
					show.setText(String.valueOf(i));
					Thread.sleep(1000);
				}
				// 黄灯亮
				red.setBackground(Color.gray);
				yellow.setBackground(Color.yellow);
				green.setBackground(Color.gray);
				for (int i = 2; i > 0; i--) {
					show.setText(String.valueOf(i));
					Thread.sleep(1000);
				}
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}


小舍test
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java线程安全基础概念解析
08-29
Java线程安全基础概念解析 Java线程安全基础概念解析是Java编程语言中一个非常重要的概念，涉及到多线程编程、同步控制、线程安全等方面。了解Java线程安全基础概念可以帮助开发者编写更加高效、可靠的多线程程序。...
java 线程的基本概念_Java线程的基本概念
weixin_31560425的博客
02-16 182
在之前的章节中，我们都是假设程序中只有一条执行流，程序从main方法的第一条语句逐条执行直到结束。从本节开始，我们讨论并发，在程序中创建线程来启动多条执行流，并发和线程是一个复杂的话题，本节，我们先来讨论Java中线程的一些基本概念。创建线程线程表示一条单独的执行流，它有自己的程序执行计数器，有自己的栈。下面，我们通过创建线程来对线程建立一个直观感受，在Java中创建线程有两种方式，一种是继承Th...
Java 多线程的基本概念及实现方式
weixin_39646626的博客
06-18 564
一 基本概念程序:     Java源程序和字节码文件被称为“程序” (Program)，是一个静态的概念。进程:    执行中的程序叫做进程(Process)，是一个动态的概念。线程:    线程是独立调度和分派的基本单位，共享进程资源。进程与程序:    §  进程是程序的一部分，程序运行的时候会产生一个或多个进程。     §  多进程: 在操作系统中能同时运行多个任务(程序)    §  ...
java线程基本概念
qq_33144941的博客
06-07 135
概念 进程：是系统进行资源分配和调度的基本单位。 线程：一个进程里面的不同的执行路径。 java创建线程的几种方式 1.new Thread().start(); 2.new Thread(Runnable).start(); 3.Executors.newCachedThreadPool()或者FutureTask+Callable 线程常用方法 sleep：睡眠，当前线程暂停一段时间让给别的线程去运行，等睡眠到规定时间自动复活 yield：当前线程正在执行的时候停下来进入等..
Java并发编程（一）线程定义、状态和属性
热门推荐
Android进阶三部曲 - 刘望舒
10-05 1万+
一 、线程和进程 1. 什么是线程和进程的区别: 线程是指程序在执行过程中，能够执行程序代码的一个执行单元。在java语言中，线程有四种状态：运行 、就绪、挂起和结束。 进程是指一段正在执行的程序。而线程有事也被成为轻量级的进程，他得程序执行的最小单元，一个进程可以拥有多个线程，各个线程之间共享程序的内功空间（代码段、数据段和堆空间）及一些进程级的资源（例如打开的文件），但是各个线程都拥
Java并发编程(二)------线程基本操作和状态转换图
面向搜素引擎编程
07-30 764
参考文章：[高并发Java 二] 多线程基础    线程的几种状态转换   1.线程概念 线程是进程内的执行单元。 使用线程的原因是，进程的切换是非常重量级的操作，非常消耗资源。如果使用多进程，那么并发数相对来说不会很高。而线程是更细小的调度单元，更加轻量级，所以线程会较为广泛的用于并发设计。 在Java当中线程的概念和操作系统级别线程的概念是类似的。事实上，Jvm将会把Java中的线程...
Java线程的基本概念
08-31
Java线程是并发编程的重要组成部分，它允许程序中有多个执行流同时运行，提高了程序的效率和响应性。...理解线程的基本概念和创建方式是Java并发编程的基础，掌握好这些知识对于开发高效、稳定的多线程应用至关重要。
java线程基础
12-21
Java线程基础是Java编程中不可或缺的一部分，尤其在开发高并发和实时响应的应用时更为重要。线程允许程序同时执行多个任务，提高了程序的效率和响应速度。 **应用程序与进程** 应用程序是用户可以执行的软件实例，...
java基本教程之多线程基本概念 java多线程教程
09-04
本文将深入探讨在JDK中新增Java.util.concurrent（JUC）包之前的Java多线程基础。 首先，我们需要理解线程的基本状态。线程在生命周期中会经历五种不同的状态： 1. 新建状态（New）：当通过`new Thread()`创建一个...
Java多线程完全概念题
07-29
在面试中，了解并掌握多线程的基本概念和技术是至关重要的。以下是一些关于Java多线程的关键知识点： 1. **线程同步**：Java中，线程同步是为了防止多个线程同时访问共享资源，导致数据不一致。主要机制有...
java线程定义_Java线程基本概念
weixin_31437143的博客
02-17 159
Java线程中断在Java中，没有可以强制线程终止的方法。 然而， interrupt 方法可以用来请求终止线程。当对一个线程调用 interrupt 方法时， 线程的中断状态将被置位。public void interrupt() {if (this != Thread.currentThread())checkAccess();synchronized (blockerLock) {Inter...
Java多线程之基本概念
天蓝色的博客
09-23 114
来源：https://www.toutiao.com/i6736445361914642956/ 简介 本文章主要简要概述Java多线程的一些基本概念与原理；因本人能力有限，若文章中与Java API以及相关书籍有议论的地方烦请各位读者留言探讨，一起共勉。 线程相关概念 什么是程序(Program)？ 程序就是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象...
Java线程之信号灯的使用
黑马程序员_ord
07-22 1671
java中的信号灯Semaphore的使用
java学习笔记_线程
今生今世的专栏
05-03 1034
一、Java线程：概念与原理 1、操作系统中线程和进程的概念 现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多
Java多线程基本概念
qq_43776742的博客
07-19 173
多线程 使用多线程可以让程序充分利用CPU资源，提高CPU的使用效率，从而解决高并发带来的负载均衡问题。 优点： CPU资源得到更合理的利用。 程序设计更加简洁。 程序响应更快，运行效率更高。 缺点： 需要更多的内存空间来支持多线程。 多线程并行访问的情况可能会影响数据的准确性。 数据被多线程共享，可能出现死锁的情况。 进程与线程 什么是进程： 是指计算机在某个数据集合上进行的一次运行...
Java中的线程基础知识
YAMgoddess
03-02 1137
Java中的线程基础知识 1、线程概念 线程是程序运行的基本执行单元。当操作系统(不包括单线程的操作系统，如微软早期的DOS)在执行一个程序时，会在系统中建立一个进程，而在这个进程中，必须至少建立一个线程（这个线程被称为主线程）来作为这个程序运行的入口点。因此，在操作系统中运行的任何程序都至少有一个主线程 线程的Java抽象内存模型如下，由此可见 1）每个线程都有自己独立的工作内存 2）线程1无法访问线程2的工作内存 3）线程在访问共享数据时,会把主内存中的共享变量复制到自己的工作内存中，线程操作的是工作内
java 线程概念_java并发编程之 java线程基本概念
weixin_34785304的博客
02-20 70
阅读建议最好使用电脑观看。如果你非要使用手机观看，那请把字体调整到最小，这样观看效果会好一些。碎片化阅读并不会得到真正的知识提升，要想有提升还得找张书桌认认真真看一会书，或者我们公众号的文章。如果觉得不错，各位帮着转发转发，如果觉得有问题或者写的哪不清晰，务必私聊我～本篇文章不是java语法的基本教程！在阅读之前，请保证你有面向对象的编程基础，熟悉封装、继承、多态，否则的话，你不适合阅读本篇文章，...
【深入理解Java原理】线程基本概念
王小明的专栏
07-25 338
Java 并发 --线程基本概念 线程的基本概念 线程是条单独的执行流，有自己的栈，和程序技术器 一般创建线程的方法有： 继承Thread 实现Runnable 实现Callable 线程的基本属性和方法 1. id和name id是一个自增的id,每新建一个线程就+1 private static synchronized long nextThreadID() ...
Java基础——线程的基本概念
weixin_47208494的博客
04-20 140
线程基础 进程与线程 进程 简介：一个正在进行的程序 从内存的角度看，当程序运行时，系统会为其分配一定的运行空间(运行内存上)，这片空间就是进程 线程 简介：代码的一条执行路径 1、Java程序在运行时自带一条线程，这条线程称为主线程(main线程) 2、一个进程中可以有多个线程 3、从宏观上考虑多个线程是同时执行的，但从微观上考虑，多个线程在抢夺CPU执行权，谁抢夺谁执行一句代码，然后重新抢夺，所以微观考虑他们是交替执行的，因为抢夺Cpu执行权的速度很快，所以说宏观上是同时执行的。 4、除在主线程外
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值