JAVA--线程（Thread）

最新推荐文章于 2024-07-27 23:50:11 发布
最新推荐文章于 2024-07-27 23:50:11 发布
阅读量3k 收藏 3
点赞数 9
分类专栏： 线程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zailalaniubi/article/details/125130696
版权

所属包：

                java.lang;

构造方法：

         public Thread();

         public Thread(String name);参数是给线程起个名字

         public Thread(Runnable target);传入要执行的Runnable对象

         public Thread(Runnable target,String name);可以同时传入中间要用“，”隔开

 静态方法：

        static Thread currentThread();获取当前线程

        static void  sleep(long millis);具体数字，毫秒值  1000毫秒=1秒

成员变量：

        private Runnable target;
      

成员方法：

        void start();//启动线程后，会执行run方法中的代码

        void run();线程执行的就是这里的内容

        String getName();获取线程的名字

        void setName(String name);也是用来给线程起一个名字

        State getState();获取线程的状态

调度方式：

                抢占式调度：给每个任务分配的时间不等。(可以理解为线程之间进行争抢，谁抢上就是谁执行任务。)
                分时调度：给每个任务分配的时间是均等的。(可以在任务完添加一个sleep来控制每个线程执行的时间。)

进程和线程：

进程：

        一个应用程序就是一个或者多个进程。


 线程：

        一个进程有一个或者多个线程。

public class Test01 {
	public static void main(String[] args) {
		while(true);
	}
}

 

 

获取线程的名字：Thread.currentThread();+ ？.getName();

public class Test01 {
	public static void main(String[] args) {
		//获取当前线程，执行当前代码的线程
		Thread currentThread = Thread.currentThread();
        //获取线程的名字
		String name = currentThread.getName();
        //打印线程的名字
		System.out.println(name);

	}
}

Runnable接口：

        public abstract void run();

Runnable接口的方式和继承Thread类的方式：建议使用Runnable方式
              a.线程和任务分离，解耦合，提高代码的健壮性。
              b.避免了Java单继承的局限性
              c.线程池里面，只能传入Runnable或者Callable类型的对象，不用new Thread
  
          每一个线程启动后都会有一个栈，各自在各自的栈中执行任务。
          线程的开销比一般对象的开销要大。

 运行一个线程：

第一种方法：

1.先创建一个继承了Thread的的类，并重写run方法（线程执行的任务就是run方法中的代码）;

public class SubThread extends Thread{
	@Override
	public void run() {
		//获取当前线程，执行当前代码的线程
		Thread t = Thread.currentThread();
		//获取线程的名称
		String name = t.getName();
		//System.out.println(name+" hello Thread");
		
		for (int i = 0; i < 100; i++) {
			System.out.println(name+"--"+i);
			try {
        //目的是让线程执行完任务睡一会儿，执行速度慢一些，方便我们看效果
				Thread.sleep(100);//单位是毫秒
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

try{}catch()是解决异常，详情可见https://so.csdn.net/so/search?spm=1001.2101.3001.7498&q=java%E5%BC%82%E5%B8%B8%E5%A4%84%E7%90%86&t=&u=&utm_term=java%E5%BC%82%E5%B8%B8%E5%A4%84%E7%90%86&utm_medium=distribute.pc_toolbar_associateword.none-task-associate_word-opensearch_query-4-java%3Cem%3E%E5%BC%82%E5%B8%B8%3C%2Fem%3E%E5%A4%84%E7%90%86-null-null.nonecase&depth_1-utm_source=distribute.pc_toolbar_associateword.none-task-associate_word-opensearch_query-4-java%3Cem%3E%E5%BC%82%E5%B8%B8%3C%2Fem%3E%E5%A4%84%E7%90%86-null-null.nonecase&request_id=165423633116781685375078&opensearch_request_id=165423633116781685375078https://so.csdn.net/so/search?spm=1001.2101.3001.7498&q=java%E5%BC%82%E5%B8%B8%E5%A4%84%E7%90%86&t=&u=&utm_term=java%E5%BC%82%E5%B8%B8%E5%A4%84%E7%90%86&utm_medium=distribute.pc_toolbar_associateword.none-task-associate_word-opensearch_query-4-java%3Cem%3E%E5%BC%82%E5%B8%B8%3C%2Fem%3E%E5%A4%84%E7%90%86-null-null.nonecase&depth_1-utm_source=distribute.pc_toolbar_associateword.none-task-associate_word-opensearch_query-4-java%3Cem%3E%E5%BC%82%E5%B8%B8%3C%2Fem%3E%E5%A4%84%E7%90%86-null-null.nonecase&request_id=165423633116781685375078&opensearch_request_id=165423633116781685375078

2.在测试类中创建该线程对象，并开始任务（？.start（）；）

public class Test02 {
	public static void main(String[] args) {
		//创建一个子线程
		Thread t = new SubThread();
        //开始任务
		t.start();
		
	}
}

注意：run()与start()的区别：

public class Test02 {
	public static void main(String[] args) {
		//创建一个子线程
		Thread t = new SubThread();
		//t.start();
		
		//如果直接调用run方法，run方法中的代码是由主线程执行的
		t.run();
	}
}

        直接调用run()方法，是主线程main去执行的，没有显示出我们子线程的作用，没有达到我们写线程的目的。

第二种方法：

使用匿名内部类创建Runnable对象；

	public static void main(String[] args) {
		Runnable a = new Runnable(){

			@Override
			public void run() {
				Thread x = Thread.currentThread();
				String name = x.getName();
				for(int i =0;i<100;i++) {
					System.out.println(name+i);
				}
				
			}
			
		};
		Thread b = new Thread(a,"线程一");
		b.start();

	}

}

 线程的并行和并发：

        并行(必须是多核CPU在可以达到)：    一个或者多个事件(任务)在同一时间点(同时)执行，好比你可以一般打游戏一边吃饭，同事进行。
        并发()：    一个或者多个事件在同一时间段(先后)执行，你有两碗饭，你只有把嘴里的解决了才能吃下一口。

多线程：

        顾名思义是多个线程同时运行

	public static void main(String[] args) {
		Runnable a = new Runnable(){

			@Override
			public void run() {
				Thread x = Thread.currentThread();
				String name = x.getName();
				for(int i =0;i<100;i++) {
					System.out.println(name+i);
				}
				
			}
			
		};
		Thread b = new Thread(a,"线程一");
		b.start();
		new Thread(a,"线程二").start();
	}

}

多线程注意：

         多个线程执行的时候：谁线程值不确定，谁执行多长时间不确定。

线程的安全：

public static void main(String[] args) throws InterruptedException {
        //创建一个集合，使其可以存入20000个元素
		ArrayList<Integer> list = new ArrayList<>(20000);
		
		//通过匿名内部类的方式创建Runnable类型的对象
		Runnable r = new Runnable() {
			@Override
			public void run() {
				for (int i = 0; i < 10000; i++) {
					list.add(i);
				}
               //用来判断是否两个线程都执行任务了
				System.out.println("=================");
			}
		};
        //用匿名对象的形式创建两个线程去执行任务
		new Thread(r).start();
		new Thread(r).start();
		
		//用来限制主线程main，防止线程还没执行完，主线程已经执行了sout；
		Thread.sleep(3000);
		System.out.println(list.size());
	}

第一次运行：

第二次运行：

 

 正常下应该是存储20000个，现在会发生丢失问题。

为什么会发生丢失问题？线程安全产生的前提：多个线程访问同一资源(数据)

        线程的执行无非就是这三步；

        

 之所以会发生错误就是线程一拿到数字了，进行第二部+1了，但是还没有执行第三步，任务被线程二抢去了，所以没存上。再等到线程一抢回来，继续存，两个数存了同一个数，就相当于丢了。

	static int n = 0;
	public static void main(String[] args) throws InterruptedException {
		Runnable r = new Runnable() {
			@Override
			public void run() {
				String name = Thread.currentThread().getName();
				for (int i = 0; i < 100; i++) {
					n++;
					System.out.println(name+n);
				}
				
			}
		};
		
		
		new Thread(r,"天线宝宝").start();
		new Thread(r,"花园宝宝").start();
		
		Thread.sleep(3000);
		System.out.println(n);
	}
}

 如何解决线程丢失（上锁）：整个的操作不是原子操作：

        在线程一进行操作时，另一个线程二进行等待，只有线程一操作完，释放锁对象，线程二才能抢。

1.使用synchronized代码块

        语法：
                  synchronized(锁对象){//可以是任意类型的对象
                      //写有可能发生线程安全问题的代码
                  }

static int n = 0;
	public static void main(String[] args) throws InterruptedException {
		Runnable r = new Runnable() {
			@Override
			public void run() {
				for (int i = 0; i < 10000; i++) {
					synchronized (this) {
						n++;
					}
				}
			}
		};
		
		new Thread(r).start();
		new Thread(r).start();
		
		Thread.sleep(3000);
		System.out.println(n);
	}

2.使用synchronized方法

        静态synchronized方法：在static和返回值之间加synchronized关键字
        非静态synchronized方法：在返回值之前加synchronized关键字

        synchronized代码块和方法：代码执行完毕后，自动释放锁

public class Testhah {
	static int n = 0;
	public static void main(String[] args) throws InterruptedException {
		
		Runnable r = new Runnable() {
			@Override
			public void run() {
				for (int i = 0; i < 10000; i++) {
					//调用synchronized方法
					add();
				}
			}
		};
		
		new Thread(r).start();
		new Thread(r).start();
		
		Thread.sleep(3000);
		System.out.println(n);
	}
	
	public static synchronized void add() {
		n++;
	}
}

 3.使用Lock锁

        Lock接口：
                  void lock();//上锁
                  void unlock();//开锁
  
                  常用实现类：ReentrantLock
                      构造方法：
                          public ReentrantLock();

public class lulalei {
	static int n = 0;
	public static void main(String[] args) throws InterruptedException {
		Lock lock = new ReentrantLock();
		
		Runnable r = new Runnable() {
			@Override
			public void run() {
				for (int i = 0; i < 10000; i++) {
					//上锁
					lock.lock();
					n++;
					//解锁
					lock.unlock();
				}
			}
		};
		
		
		new Thread(r).start();
		new Thread(r).start();
		
		Thread.sleep(3000);
		System.out.println(n);
	}
	
}

 线程的状态：

        NEW：新建状态。创建了一个线程，启动之前处于该状态

public class Test01 {
	public static void main(String[] args) {
		Thread t = new Thread();
		State  s = t.getState();
		System.out.println(s);//NEW
	}
}

         RUNNABLE:可运行状态

public class Test03 {
	public static void main(String[] args) throws InterruptedException {
		Runnable r = new Runnable() {
			@Override
			public void run() {
				for(;;);
			}
		};
		Thread t = new Thread(r);
		t.start();
		
		Thread.sleep(100);//100毫秒保证子线程开始执行Thread.sleep(1000000);这一行代码了
		//获取并打印线程的状态
		System.out.println(t.getState());
	}
}

 

        BLOCKED：阻塞状态

 

public class Test05 {
	public static void main(String[] args) throws InterruptedException {
		Runnable r = new Runnable() {
			@Override
			public void run() {
				synchronized(this) {
					for(;;);
				}
			}
		};
		Thread t1 = new Thread(r);
		t1.start();
		Thread t2 = new Thread(r);
		t2.start();
		
		Thread.sleep(100);//100毫秒保证两个子线程已经启动，并开始执行代码了
		//获取并打印线程的状态
		System.out.println(t1.getState());
		System.out.println(t2.getState());
		//获取了锁对象开始执行for循环的线程处于RUNNABLE状态
		//没有获取锁对象的线程处于BLOCKED状态。
	}
}

        WAITING：无限等待状态

public class Test06 {
	public static void main(String[] args) throws InterruptedException {
		Lock lock = new ReentrantLock();
		
		Runnable r = new Runnable() {
			@Override
			public void run() {
					lock.lock();
					for(;;);
			}
		};
		Thread t1 = new Thread(r);
		t1.start();
		Thread t2 = new Thread(r);
		t2.start();
		
		Thread.sleep(100);//100毫秒保证两个子线程已经启动，并开始执行代码了
		//获取并打印线程的状态
		System.out.println(t1.getState());
		System.out.println(t2.getState());
		//获取了锁对象开始执行for循环的线程处于RUNNABLE状态
		//没有获取Lock锁对象的线程处于WAITING状态。
	}
}

 

        TIMED_WAITING:计时等待状态

public class Test04 {
	public static void main(String[] args) throws InterruptedException {
		Runnable r = new Runnable() {
			@Override
			public void run() {
				try {
					Thread.sleep(1000000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		};
		Thread t = new Thread(r);
		t.start();
		
		Thread.sleep(100);//100毫秒保证子线程开始执行Thread.sleep(1000000);这一行代码了
		//获取并打印线程的状态
		System.out.println(t.getState());
	}
}

 

        TERMINATED：消亡状态

public class Test02 {
	public static void main(String[] args) throws InterruptedException {
		Runnable r = new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName());
			}
		};
		Thread t = new Thread(r);
		t.start();
		
		Thread.sleep(1000);//1000毫秒子线程一定把任务执行完毕了
		//获取并打印线程的状态
		System.out.println(t.getState());
	}
}

 

线程的通信：线程和线程之间的沟通

        等待唤醒机制：

                        Object类：

               void wait();//就会让线程进入等待状态。WAITING状态
              void wait(long time);//调用该方法，会让线程进入计时等待状态。TIMED_WAITING
              void notify();//调用该方法，会让线程醒来，接着执行任务。
              void notifyAll();//调用该方法，会唤醒当前锁对象上等待的所有线程

注意事项：

        1.这些方法都必须写在synchronized代码块或者synchronized方法中           

        2.调用这些方法的对象，必须和锁对象一致。

        3.  t.notify方法,只能唤醒t锁对象上等待的线程

        4.  调用了wait(不论是否有参数)方法后，会自动释放锁对象。

例子：

1.创建一个Fruit类

public class Fruit {
	private int stock;
	public int getStock() {
		return stock;
	}
	public void setStock(int stock) {
		this.stock = stock;
	}
	
}

2.官网线程类

public class NetShop implements Runnable{
	private Fruit f;
	public NetShop(Fruit f) {
		super();
		this.f = f;
	}

	@Override
	public void run() {
		while(true) {
			synchronized(f) {
				//判断是否退出循环
				if(f.getStock()<=0) {
					break;
				}
				//偶数份，官网卖
				if(f.getStock()%2==0) {
					//每卖一份，库存减1
					f.setStock(f.getStock()-1);
					System.out.println("官网正在卖出第"+(100-f.getStock())+"份，还剩余"+f.getStock()+"份");
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					//唤醒当前锁对象上等待的线程
					f.notify();
				}else {
					//奇数份，官网进入等待状态
					try {
						f.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}
	}
}

3.实体店线程类

public class FrontShop implements Runnable{
	private Fruit f;
	public FrontShop(Fruit f) {
		super();
		this.f = f;
	}

	@Override
	public void run() {
		while(true) {
			synchronized(f) {
				//判断是否退出循环
				if(f.getStock()<=0) {
					break;
				}
				//奇数份，实体店卖
				if(f.getStock()%2==1) {
					//每卖一份，库存减1
					f.setStock(f.getStock()-1);
					System.out.println("实体店正在卖出第"+(100-f.getStock())+"份，还剩余"+f.getStock()+"份");
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					//唤醒当前锁对象上等待的线程
					f.notify();
				}else {
					//偶数份，实体店进入等待状态
					try {
						f.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}
	}
}

4.测试类

public class Test01 {
	public static void main(String[] args) {
		//创建Fruit类型的对象
		Fruit f = new Fruit();
		f.setStock(100);
		
		//创建官网和实体店类型的对象
		Runnable r1 = new NetShop(f);
		Runnable r2 = new FrontShop(f);
		
		//创建两个线程，分别指向这两个任务
		new Thread(r1).start();
		new Thread(r2).start();
	}
}

 注意：

        我们做这个题要明确两点：

        1.这两边需要一个共同的锁对象
        2.根据库存去判断谁该执行了，谁该等待了

线程池：

        简单来说就是一个存放线程的池子，线程执行完任务会回到池子里面等待下一个任务的到来，提高效率。

        1.提高响应速度。预先创建好了线程，只等任务过来执行。

        2.降低资源消耗。线程池中的线程，执行完任务后，又返回到线程池中，下一个任务到来后可以继续使用该线程。

        3.提高线程的可管理性。一个线程大约需要消耗1M的空间，线程池可以设置最大线程的数量。

Executors类：

        static ExecutorService newFiexdThredadPool(int nThread);

ExecutorService接口：

        void execute(Runnable r);//执行任务
        <T> Future<T> submit(Callable<T> c);//执行任务
        Future<?> submit(Runnable r);//执行任务
        void shutdown();//关闭线程池

public class Test01 {
	public static void main(String[] args) {
		Runnable r = new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName());
			}
		};
		
		//创建一个固定线程池对象
		ExecutorService es = Executors.newFixedThreadPool(2);
		//执行任务
		es.execute(r);
		//关闭线程池
		es.shutdown();
	}
}

 

下面是如果有多个任务线程池怎么运行：

public class Test02 {
	public static void main(String[] args) {
		Runnable r = new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName());
				try {
					Thread.sleep(10000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		};
		
		//创建一个固定线程池对象
		ExecutorService es = Executors.newFixedThreadPool(2);
		//执行任务
		es.execute(r);
		es.execute(r);
		es.execute(r);
		//关闭线程池
		es.shutdown();
	}
}

         从结果，可以看出来，先执行任务的那个把任务执行完，接着把第三次任务执行了，后执行任务的，执行完任务就回到了线程池。

 

Future<T>接口

        T get();//必须等子线程把任务执行完成，return以后才可以获取返回的结果。

Callable<T>接口(与Runnable很像)：

        T call();

public class Test04 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		Runnable r = new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName());
			}
		};
		
		//创建一个固定线程池对象
		ExecutorService es = Executors.newFixedThreadPool(2);
		Future<?> future = es.submit(r);
		Object result = future.get();//null
		System.out.println(result);
		//关闭线程池
		es.shutdown();
	}
}

        

 可以看出来Runnable没有返回值，所以就不用接收了。

public class Test03 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		Callable<String> c = new Callable<String>() {
			@Override
			public String call() throws Exception {
				//call方法中的代码是某个子线程执行的
				System.out.println(Thread.currentThread().getName());
				Thread.sleep(5000);
				return "test callable";
			}
		};
		
		//创建一个固定线程池对象
		ExecutorService es = Executors.newFixedThreadPool(2);
		Future<String> future = es.submit(c);
		
		//这行代码是主线程执行的
		String result = future.get();
		System.out.println(result);
		//关闭线程池
		es.shutdown();
	}
}

 

意Ω外
关注
  • 9
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
6-7 jmu-Java-07多线程-Thread (3分)
嗯呢嗯呢的博客
06-06 2949
6-7jmu-Java-07多线程-Thread(3分) 编写MyThread类继承自Thread。创建MyThread类对象时可指定循环次数n。功能：输出从0到n-1的整数。 并在最后使用System.out.println(Thread.currentThread().getName()+" "+isAlive())打印标识信息 裁判测试程序： import java.util.Scanner; /*这里放置你的答案，即MyThread类的代码*/ public class Main {..
java 打印 线程_java线程状态和获取线程基本信息
weixin_42625070的博客
02-12 2925
1. 线程状态新生状态用 new 关键字建立一个线程后，该线程对象就处于新生状态。处于新生状态的线程有自己的内存空间，通过调用start()方法进入就绪状态。就绪状态处于就绪状态线程具备了运行条件，但还没分配到 CPU，线程处于就绪队列，等待系统为其分配 CPU。当系统选定一个等待执行的线程后，它就会从就绪状态进入执行状态，该动作称为“CPU 调度”。运行状态运行状态的线程执行自己的 run 方法...
多线程基础
Stay Hungry, Stay Foolish!
09-30 1914
文章目录一、多线程1. 1 并发与并行1. 2 线程与进程1. 3 Thread创建线程1. 4 Runnable创建线程1. 5 匿名内部类创建线程二、线程安全2. 1 Java内存模型（JMM）2. 2 线程安全2. 2 线程同步三、生命周期3. 1 概述3. 2 新建状态(NEW)3. 3 运行状态(RUNNABLE)3. 4 阻塞状态(BLOCKED)3. 5 等待状态(WAITING)3. 6 超时等待状态(TIMED_WAITING)3. 7 终止状态（TERMINATED）四、等待唤醒机制4.
《知识点003：Java使用Thread.currentThread()获取当前线程》
最新发布
大大大钢琴
07-27 278
1. Thread提供静态方法currentThread()来供我们调用，既可以避免this无法获取到main线程的问题，又可以避免this无法获取到Thread t2=new Thread(Thread t)来开启的线程的问题，可以说currentThread方法可以在所有场合获取到正确的当前线程。‌通过这个方法，‌可以获取当前线程的各种属性，‌如线程名称、‌优先级、‌是否为守护线程等，‌并且可以对这些属性进行修改。‌当调用此方法时，‌当前线程的中断状态会被设置，‌如果线程处于阻塞状态（‌如调用。
Java 实例 - 获取当前线程名称
rockly89的博客
09-08 3658
以下实例演示了如何通过继承 Thread 类并使用 getName() 方法来获取当前线程名称： /* author by w3cschool.cc TwoThreadGetName.java */ public class TwoThreadGetName extends Thread { public void run() { for (int i = 0; i
Java多线程 currentThread 方法打印出不同的线程名字
Java持续实践
08-30 5393
currentThread 方法打印出不同的线程名字 如下的代码 演示了currentThread 方法打印出不同的线程名字. /** * 类名称:CurrentThread * 类描述: 演示打印main, Thread-0, Thread-1 * * @author: https://javaweixin6.blog.csdn.net/ * 创建时间:2020/8/30 15:32 * Version 1.0 */ public class CurrentThread implements
编写一个Java程序实现多线程，在线程中输出线程的名字，隔300毫秒输出一次，共输出20次
xinyi_java的博客
09-10 5065
package test10; /** * @program: TestDemo * @description: 编写一个Java程序实现多线程，在线程中输出线程的名字，隔3000毫秒输出一次，共输出20次。 * @author: xin yi * @create: 2021-09-10 19:06 */ public class Demo06 { public static void main(String[] args) { /** * 线程a .
6-1 jmu-Java-07多线程-Thread (20分)
sddfnsff的博客
05-26 6026
编写MyThread类继承自Thread。创建MyThread类对象时可指定循环次数n。 功能：输出从0到n-1的整数。 并在最后使用System.out.println(Thread.currentThread().getName()+" "+isAlive())打印标识信息 裁判测试程序： import java.util.Scanner; /这里放置你的答案，即MyThread类的代码/ public class Main { public static void main(String[] args
Java-Thread-Affinity,将Java线程绑定到给定的内核.zip
09-25
Java线程亲和性（Thread Affinity）是一个高级并发编程概念，主要涉及到操作系统调度和硬件资源的优化。在多核处理器系统中，线程亲和性允许开发者指定某个线程应该运行在哪个特定的处理器核心上，从而提高性能、...
JAVA线程高级-线程按序交替执行
11-01
- Java的`Thread`类提供了设置线程优先级的方法，如`setPriority()`，但优先级并不保证绝对的执行顺序，只能影响调度概率，实际执行顺序依赖于JVM和操作系统。 7. **`Thread.yield()`**： - `Thread.yield()`方法...
6-2 jmu-Java-07多线程-交替执行 (25分)
sddfnsff的博客
06-04 3823
有一连串任务，需要两个线程交替执行。线程1执行完任务1后，线程2才能执行任务2，接下来线程1执行任务1，如此交替执行下去。直到所有任务执行完毕。 定义Repo类代表任务仓库，使用字符串代表任务。该类拥有： 构造函数: /将传递进来的字符串以空格分隔分解为多个不同的任务，并存储起来。如"1 2 3 4 5 6"被分解成6个任务1,2,3,4,5,6/ public Repo(String items) { } 方法： int getSize(); //返回Repo包含的任务数量。注意：完成任务的时候，需要将
3个线程，根据不同规则打印线程名称
09-02
编写一个程序，开启3个线程，这3个线程的ID分别为A、B、C。 如果要求打印 ABCBCACAC,线程对应打印信息到控制台。 缺点：耗费cpu
java获得当前线程的名称
彦楠的博客
12-19 2077
//获得当前线程的名称 System.out.println(Thread.currentThread().getName());
java实现多线程输出线程名称_Java：多线程，分别用Thread、Runnable、Callable实现线程...
weixin_42511769的博客
02-23 2368
并发性(concurrency)和并行性(parallel)是两个概念，并行是指在同一时刻，有多条指令在多个处理器上同时执行；并发指在同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，使得宏观上具有多个进程同时执行的效果。多线程编程优点：进程之间不能共享内存，但线程之间共享内存非常容易。系统创建线程所分配的资源相对创建进程而言，代价非常小。Java中实现线程的方式目前有三种：一：继承Thr...
java打印前线程的id_[编程题] 打印出失序的线程ID--字节跳动笔试题
weixin_39930557的博客
02-16 409
打印出失序的线程ID题目描述输入一个正整数n.表示接下来有n行数字，每行一个数字(不重复，可能无序)，表示线程id,输出未出现的失序的线程IDn的大小是小于等于2的32次方示例例如1：输入(输入的线程ID不一定有序)523456输出：1例如2：输入：41234输出：5Java代码package ncompanydemos.p2_bytedance;import java.util.Arrays;i...
java获取线程名_Java获取线程的对象和名称
weixin_42303803的博客
02-12 168
/*获取线程对象以及名称(很有意义的)原来线程都有自己默认的名称Thread-编号 该编号从0开始Thread 父类的方法static Thread currentThread() :获取当前线程对象 相当于thisgetName 获取线程名称*/class Text extends Thread{//private String name;Text(String name){//this....
java多线程之获取和设置线程对象名称
kaszxc的博客
09-29 563
package cn.itcast_02; /* * 如何获取线程的对象名称呢？ * public final String getName():获取线程的名称 * 如何设置线程对象名称 * public final void setName(String name):设置线程的名称 * * 针对不是Thread类中的子类如何获取线程对象呢？ * public static Thread currentThread();返回当前执行的线程对象 * Thread.currentThre
java：打印当前线程所在的线程组、及子线程组中所有活动的平台线程的堆栈信息
听海边涛声
12-22 511
java：打印当前线程所在的线程组、及子线程组中所有活动的平台线程的堆栈信息
Java获取线程的对象和名称
weixin_33858485的博客
07-10 608
/*获取线程对象以及名称（很有意义的）原来线程都有自己默认的名称Thread-编号 该编号从0开始Thread 父类的方法static Thread currentThread（） :获取当前线程对象 相当于this getName 获取线程名称*/class Text extends Thread{ //private String name; Text(String nam...
jmu-java-07多线程-thread
03-16
JMU Java 07 多线程 (Thread) 是指在 Java 语言中使用多个线程来同时执行多个任务的技术。通过使用多线程，可以提高程序的并行处理能力，加快程序的执行速度，提高程序的效率。在 Java 中，多线程可以通过继承 java....
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值