线程中currentThread方法

线程中currentThread方法用于获取执行当前方法代码的线程,是什么意思?谁能解释的详细些额,谢谢!

5个回答

线程中currentThread方法用于获取执行当前方法代码的线程,这已经够明显啦。

因为一个应用中可能存在多个线程的情况,比如Android中的UI线程、请求网络的子线程等等

就是拿来代表当然线程的一个方法而已,当前线程的代称,比如Thread.currentThread()就是当前线程,要获取当前线程的名字就可以用Thread.currentThread().getName()

首先你得知道进程和线程的相关知识,java中,一个程序可能有多个进程,某个方法可能就在某一个进程中,当我们在某个线程的方法中调用currentThread()方法时,就会得到执行该方法的线程。

比如安卓启动后,运行在UI线程中,因此你这个方法获得的就是UI线程的对象引用,那么你可以用来做一些操作;
如果是在子线程当中获得是子线程的对象引用;
一般情况下可以通过设置标签来管理线程,这也就是此方法的意义所在。

Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
其他相关推荐
关于四个线程同步控制数字加减的问题
Resource类中的add()方法和sub()方法首先if判断flag状态,如果为true应该执行 this.wait()线程进入等待状态。如果为false执行else{}中的语句。按理说if(){}后的语句不用else{}扩起来应该不影响功能的实现,看视频老师就没用else{}括起来if后的语句,可是我的代码如果不用else{}把if后的语句扩起来就达不到效果。求解答是为什么!!琢磨了好久,能力有限没想明白。 ``` public class AddSubThreadDemo { public static void main(String[] args) { Resource rsc = new Resource(); AddThread at = new AddThread(rsc); SubThread st = new SubThread(rsc); new Thread(at, "加法线程 - A").start(); new Thread(at, "加法线程 - B").start(); new Thread(st, "减法线程 - X").start(); new Thread(st, "减法线程 - Y").start(); } } class Resource { private int num = 0; private boolean flag = true; // 如果flag为true,执行加法操作;如果flag为false,执行减法操作。 //加法方法 public synchronized void add() throws Exception { if (this.flag == false) { super.wait(); }else { //这里的else{}去掉就会出现错误结果 Thread.sleep(100); this.num++; System.out.println("【加法操作 - " + Thread.currentThread().getName() + "】num = " + this.num); this.flag = false; super.notifyAll();} } //减法方法 public synchronized void sub() throws Exception { if (this.flag == true) { super.wait(); }else { //这里的else{}去掉就会出现错误结果 Thread.sleep(200); this.num--; System.out.println("【减法操作 - " + Thread.currentThread().getName() + "】num = " + this.num); this.flag = true; super.notifyAll();} } } //加法线程 class AddThread implements Runnable { private Resource resource; public AddThread(Resource resource) { this.resource = resource; } @Override public void run() { for (int i = 0; i < 100; i++) { try { this.resource.add(); } catch (Exception e) { e.printStackTrace(); } } } } //减法线程 class SubThread implements Runnable { private Resource resource; public SubThread(Resource resource) { this.resource = resource; } @Override public void run() { for (int j = 0; j < 100; j++) { try { this.resource.sub(); } catch (Exception e) { e.printStackTrace(); } } } } ```
Java中静态方法的线程安全问题
Java中多个线程同时访问一个静态方法是否存在线程安全问题? 比如以下代码,两个线程同时对方法中b修改不同的值,会有线程安全问题吗? new Thread(new Runnable() { @Override public void run() { fun(0); } }).start(); new Thread(new Runnable() { @Override public void run() { fun(1); } }).start(); } static void fun(int a) { int b = 100; b = a; for (int i=0; i<100; i++) System.out.println(Thread.currentThread().getName() + "-->" + b); }
Java线程中synchronized 使用?
挂起方法hangUP,如果不加synchronized,恢复后,后面的println为什么不能执行。 public class Example8_12{ public static void main(String args[]){ MyThread thread=new MyThread(); thread.setName("张三"); thread.start(); while(thread.getStop()==false){} System.out.println("我是主线程,负责恢复"+thread.getName()+"线程"); thread.restart(); } } class MyThread extends Thread{ int number=0; boolean stop=false; boolean getStop(){ return stop; } public void run(){ while(true){ number++; System.out.println(Thread.currentThread().getName()+"的number="+number); if(number==3){ try{ System.out.println(Thread.currentThread().getName()+"被挂起"); stop=true; hangUP(); System.out.println(Thread.currentThread().getName()+"恢复执行"); } catch(Exception e){} } try{Thread.sleep(1000);} catch(Exception e){} } } public synchronized void hangUP() throws InterruptedException{ wait(); } public synchronized void restart(){ notifyAll(); } } ![图片说明](https://img-ask.csdn.net/upload/202001/06/1578280121_823024.jpg) 不加synchronized: public class Example8_12{ public static void main(String args[]){ MyThread thread=new MyThread(); thread.setName("张三"); thread.start(); while(thread.getStop()==false){} System.out.println("我是主线程,负责恢复"+thread.getName()+"线程"); thread.restart(); } } class MyThread extends Thread{ int number=0; boolean stop=false; boolean getStop(){ return stop; } public void run(){ while(true){ number++; System.out.println(Thread.currentThread().getName()+"的number="+number); if(number==3){ try{ System.out.println(Thread.currentThread().getName()+"被挂起"); stop=true; hangUP(); System.out.println(Thread.currentThread().getName()+"恢复执行"); } catch(Exception e){} } try{Thread.sleep(1000);} catch(Exception e){} } } public void hangUP() throws InterruptedException{ wait(); } public synchronized void restart(){ notifyAll(); } } ![图片说明](https://img-ask.csdn.net/upload/202001/06/1578280328_552003.jpg) ``` ```
java System.out.println("当前线程"+Thread.currentThread());返回两个结果是为什么?
package animal; class HelloThread implements Runnable { int i; public void run() { i=0; System.out.println("当前线程"+Thread.currentThread());//第一个 while(true) { System.out.println("当前线程"+Thread.currentThread().getName()); System.out.println("Hello"+i++); if(i>5) break; } } } public class text { public static void main(String[]args) { HelloThread r=new HelloThread(); Thread t=new Thread(r); Thread t2=new Thread(r); t.start(); t2.start(); } } 结果 当前线程Thread[Thread-1,5,main] 当前线程Thread-1 当前线程Thread[Thread-0,5,main] 当前线程Thread-0 Hello1 当前线程Thread-0 Hello2 Hello0 当前线程Thread-1 Hello3 当前线程Thread-1 Hello4 当前线程Thread-1 Hello5 当前线程Thread-0 Hello6 为什么【第一个】那里的返回了2个地址,上面Hello1前有4个【当前线程。。。。】 他们是有先后顺序的吗
新线程开启的方法自动跳到主线程
这是课本上的一个例子,我想跟踪线程,于是加了几处Log打印,但遇到了问题: package com.mingrisoft; import android.app.Activity; import android.media.MediaPlayer; import android.media.MediaPlayer.OnCompletionListener; import android.os.Bundle; import android.util.Log; import android.view.View; import android.view.View.OnClickListener; import android.widget.Button; import android.widget.Toast; public class MainActivity extends Activity { protected static final String TAG = "MainActivity"; private Thread thread; // 声明一个线程对象 private static MediaPlayer mp = null; // 声明一个MediaPlayer对象 @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); // Log.i("AAA",String.valueOf(Thread.currentThread().getId()) ); Button button = (Button) findViewById(R.id.button1); // 获取布局管理器中添加的“开始”按钮 button.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { ((Button) v).setEnabled(false); // 设置按钮不可用 // 创建一个用于播放背景音乐的线程 thread = new Thread(new Runnable() { @Override public void run() { playBGSound(); // 播放背景音乐 } }); thread.start(); // 开启线程 // Toast.makeText(MainActivity.this, "运行的线程有:"+Thread.currentThread().getName(), Toast.LENGTH_SHORT).show(); // Log.i(TAG, Thread.currentThread().getName()); } }); } // 播放背景音乐 private void playBGSound() { Log.i(TAG, String.valueOf(Thread.currentThread().getId())); if (mp != null) { mp.release(); // 释放资源 } mp = MediaPlayer.create(MainActivity.this, R.raw.dang); mp.start(); // 开始播放 // 为MediaPlayer添加播放完成事件监听器 mp.setOnCompletionListener(new OnCompletionListener() { @Override public void onCompletion(MediaPlayer mp) { try { Thread.sleep(2000); // 让当前线程休眠2秒钟 playBGSound(); // 重新播放音乐,回到主线程里 } catch (InterruptedException e) { e.printStackTrace(); } } }); } @Override protected void onDestroy() { if (mp != null) { mp.stop(); // 停止播放 mp.release(); // 释放资源 mp = null; } if (thread != null) { thread = null; } super.onDestroy(); } } 运行结果先后是 153,1,1,1,(重复是1)。不知道为什么onCompletion()方法里,在新线程休眠2s后playBGSound()会转到主线程里执行?因为我是在新线程里调用这个函数的呀,求大神解答。
ThreadLocal在其他线程中get不到set的变量
牛客网项目中用spring boot做的图书管理系统中, private static ThreadLocal<User> host = new ThreadLocal<>(); public static User getHost() { return host.get(); } public static void setHost(User user) { host.set(user); } 在LoginBiz类中ConcurrentUtils.setHost(user);后面调用getHost()能获取user 在BookController类中ConcurrentUtils.getHost();user为null 这是什么原因,怎么解决呢。。 项目中有两个controller,一个bookcontroller,一个logincontroller,在logincontroller的@RequestMapping(path = {"/users/register/do"},method = {RequestMethod.POST})中sethost(user),然后在bookcontroller中@RequestMapping(path = {"/index"}, method = {RequestMethod.GET}) gethost();这应该是不同线程的吧,我用System.out.println(Thread.currentThread());也显示是不同的线程。
java多线程池中指定某个线程终止
public void run() { try { System.out.println(Thread.currentThread().getName()+“启动”); Thread.sleep(100000); System.out.println(Thread.currentThread().getName()+“停止”); } catch (InterruptedException e) { System.out.println("线程被终止"); } } funcation(){ a.start } 假设线程a b c……按顺序启动,我现在想停下b,如何操作
关于Java线程的isInterrupted方法问题
我调用interrupt方法中断线程后,isInterrupted仍然为false。看代码第二个注释处 ``` public class InterruptThread { public static void main(String[] args) { Mythread mythread= new Mythread(); mythread.start(); try { Thread.sleep(10000);//主线程休眠十秒,让子线程执行十秒,然后中断mythread子线程 mythread.interrupt(); Thread.sleep(3000); //明明调用了mythread.interrupt(),下面这句却还是false,这是为何? System.out.println("线程是否已经中断:"+mythread.isInterrupted()); System.out.println("线程是否已经中断:"+mythread.interrupted()); } catch (InterruptedException e) { e.printStackTrace(); } } } class Mythread extends Thread{ @Override public void run(){ try { while(true){ interruptableMethod(); } } catch (InterruptedException e) { System.out.println(Thread.currentThread().getName()+"线程中断了"); } } public void interruptableMethod() throws InterruptedException{ System.out.println("方法开始执行"); sleep(2000); System.out.println("方法结束"); } } ```
c# 关于_方法内局部变量和线程栈_的问题
static void Main(string[] args) { System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance); int a = 0; int b = 0; int c = 0; Task.Run(() => { while (true) { Console.WriteLine("我是Task任务中的方法,ThreadID:{0}", Thread.CurrentThread.ManagedThreadId); Console.WriteLine("a={0},b={1},c={2}", a, b, c); Thread.Sleep(1000); } }); Thread.Sleep(500); while (true) { Thread.Sleep(1000); a++; b++; c++; Console.WriteLine("我是主线程中的方法,ThreadID:{0}", Thread.CurrentThread.ManagedThreadId); Console.WriteLine("a={0},b={1},c={2}", a, b, c); } } 请问一下大家: 1.方法内的局部变量是否在线程栈上? 2.线程栈上的变量可否在多个线程之间共享? 3.在Task.Run中,在新线程执行时,是不是要将原线程栈中的局部变量复制到新线程的线程栈中? 4.为什么在 主线程中 对方法内 局部变量 的修改,会影响另一个线程(Task) 这4个问题是关联的,如果前面的问题有错误,那么后面的问题也就无意义啦! 请大家指教!
java多线程中关于使用notify()方法的几个疑问
代码: ``` public class NotifyAndWaitTest2 implements Runnable { public int i = 0; public Object lock; public SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS"); public NotifyAndWaitTest2(Object o) { this.lock = o; } @Override public void run() { synchronized (lock) { System.out.println(Thread.currentThread().getName() + " enter the SYNCHRONIZED block --- "+ sdf.format(new Date())); try { while (i < 9) { Thread.sleep(500); lock.notify(); lock.wait(); System.out.println(Thread.currentThread().getName() + " say:" + i++ + " --- " + sdf.format(new Date())); } lock.notify(); return; } catch (Exception e) { e.printStackTrace(); } } } public static void main(String[] args) { Object lock = new Object(); NotifyAndWaitTest2 test = new NotifyAndWaitTest2(lock); Thread t1 = new Thread(test,"Thread A"); Thread t2 = new Thread(test,"Thread B"); Thread t3 = new Thread(test,"Thread C"); Thread t4 = new Thread(test,"Thread D"); t1.start(); t2.start(); t3.start(); t4.start(); } } ``` 执行结果: ``` Thread A enter the SYNCHRONIZED block --- 10:47:07.242 Thread B enter the SYNCHRONIZED block --- 10:47:07.743 Thread C enter the SYNCHRONIZED block --- 10:47:08.243 Thread D enter the SYNCHRONIZED block --- 10:47:08.743 Thread C say:0 --- 10:47:09.243 Thread D say:1 --- 10:47:09.744 Thread C say:2 --- 10:47:10.244 Thread D say:3 --- 10:47:10.744 Thread C say:4 --- 10:47:11.245 Thread D say:5 --- 10:47:11.745 Thread C say:6 --- 10:47:12.246 Thread D say:7 --- 10:47:12.746 Thread C say:8 --- 10:47:13.247 Thread D say:9 --- 10:47:13.247 Thread B say:10 --- 10:47:13.247 Thread A say:11 --- 10:47:13.247 ``` 这段代码我在 jdk1.7 和 jdk1.8 中都执行过,结果是"相同的" 我主要有两个问题:(以我贴出的这个执行结果为例) 1、在线程A 和线程B 进入了同步代码块之后,并且线程B 调用了 wait() 方法,为什么接下来一定是另外两个线程进入同步代码块?而不是线程A 开始打印 say。是"让新的线程进入同步代码块"的优先级比"调用wait()方法的线程被唤醒"的优先级高吗? 2、为什么调用 notify() 方法只能唤醒最后一个调用了 wait() 方法的线程?就像上面这个执行结果,只有线程C 和线程D 互相唤醒对方,为什么不能唤醒其他的线程,比如线程A 和线程B? 我认为抢对象锁应该是不规律的、随机的,比如这样: ``` Thread A enter the SYNCHRONIZED block Thread B enter the SYNCHRONIZED block Thread A say:0 Thread C enter the SYNCHRONIZED block Thread B say:1 Thread A say:2 Thread D enter the SYNCHRONIZED block Thread B say:3 Thread C say:4 ```
在main方法中开启线程与@Test中开启线程
用来测试线程同步问题的代码: [code="java"] public class SynchronizeDemo { private static final int ticks = 10; private static double tickets = ticks; private static double price = 5; private static double total = 0; private static boolean print = true; public static void main(String[] args) { System.out.println(Thread.currentThread()); System.out.println(Thread.currentThread().isDaemon()); new saller().start(); new saller().start(); new saller().start(); // while(tickets != 0) { // } } @Test public void test() { // Thread daeom = new daemont(); // daeom.setDaemon(true); // daeom.start(); System.out.println(Thread.currentThread()); System.out.println(Thread.currentThread().isDaemon()); new saller().start(); new saller().start(); new saller().start(); } public static class saller extends Thread { @Override public void run() { while(tickets != 0) { tickets -= 1; total += price; // System.out.println(getName() + ": " + tickets + " left, total=" + total); System.out.println( Thread.currentThread() + ": " + tickets + " left, total=" + total); try { Thread.sleep(100); } catch(InterruptedException e) { e.printStackTrace(); } } if(tickets == 0 && print) { System.out.println("Total should be :" + 5 * ticks + "; "); print = false; } } } // public static class daemont extends Thread { // @Override // public void run() { // while(true) { // System.out.println("I`m a daemon...."); // try { // Thread.sleep(1000); // } catch(InterruptedException e) { // e.printStackTrace(); // } // } // } // } } [/code] 测试结果如下: 1. 在 main 方法中开启三个线程, 如果 main 方法结束(主线程结束--Thread[main,5,main]),子线程不会结束继续运行; 2. 在 @Test 方法中开启三个线程, 如果 @Test 方法结束, 子线程也会结束(每个子线程仅输出一次...); 在两种情况中 子线程的 toString() 结果都一致: Thread[Thread-0,5,main] Thread[Thread-1,5,main] Thread[Thread-2,5,main] 请问这是为什么? 为什么在 Junit 框架下的 @Test 方法中开启的子线程会在测试方法结束时一并结束?? 尝试过在 @Test 方法中添加一个 守护线程, 但是无效....
想自己编写一个线程死锁产生的例子,加深对synchronize的理解,但是发现了这个,理解不了
我的思路: 在一个类中弄两个个方法,一个A,B都加锁,要想A要得到B,B也想得到A,这样就能产生死锁。因为是同一个类,所以为了能使线程调用方法A和方法B,需要在run方法中对两个方法都调用一次,单一 一个线程按照顺序调用A、B方法就会陷入死循环,所以我用了一下方式,但还是陷入了死循环,谁能解释一下,我能得到的结论就是synchronized修饰的方法是把整个类中所有带有synchronized修饰方法都上锁了,是不是啊? ``` public class SynchronizedLocked_Dead implements Runnable { private static int num = 0 ; public synchronized void get1(){ System.out.println(Thread.currentThread().getName()+",调用1"); //准备创建两个线程,让线程1跳过getP()方法,然后线程2进来直接进入getP()方法 num++; if(num>1){ getP(); } } public synchronized void getP(){ System.out.println(Thread.currentThread().getName()+"这是P:"); //为了让线程1执行完get1方法后,睡着,好让线程2能够顺利抢占到get1方法, //并且等待线程1释放getP()方法 try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } //线程1睡醒就想运行get1方法,但是此时线程2应该还在get1方法中等待getP方法释放 //此时线程1又想获取线程2中的getP方法,所有陷入死锁 get1(); } @Override public void run() { System.out.println(""); System.out.println(Thread.currentThread().getName()+"进来了"); System.out.println(""); get1(); getP(); } public static void main(String[] args) { SynchronizedLocked_Dead me = new SynchronizedLocked_Dead(); new Thread(me,"t1").start(); new Thread(me,"t2").start(); } } ``` 运行结果: t1进来了 t1,调用1 t1这是P: **t2进来了**//就这一下下就没了? t1,调用1 t1这是P: t1,调用1 t1这是P: t1,调用1 t1这是P: t1,调用1 t1这是P: ......................死循环
java 后台线程中创建一个线程问题求解
今晚在看Think In Java的时候,看到后台线程这一小节,突然有个想法,如果在一个守护线程里面创建一个非守护线程(不显示的设置setDaemon(true)),那么创建的非守护线程是否也变成了守护线程。 代码如下 package com.hq.day0601; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; /** * 简单的后台线程(守护线程)练习,该练习主要演示的是后台线程在最后一个非后台线程结束后,也会被关闭 * @author Administrator * */ public class SimpleDaemons implements Runnable { <span style="white-space:pre"> </span>@Override <span style="white-space:pre"> </span>public void run() {<span style="white-space:pre"> </span> <span style="white-space:pre"> </span>try { <span style="white-space:pre"> </span>ExecutorService exec = Executors.newCachedThreadPool(); <span style="white-space:pre"> </span>exec.execute(new TestThread());<span style="white-space:pre"> </span> <span style="white-space:pre"> </span>TimeUnit.MILLISECONDS.sleep(100); <span style="white-space:pre"> </span>System.out.println("SimpleDaemons is Daemons:"+Thread.currentThread().isDaemon()); <span style="white-space:pre"> </span>System.out.println(Thread.currentThread() +" "+this ); <span style="white-space:pre"> </span> <span style="white-space:pre"> </span>} catch (InterruptedException e) {<span style="white-space:pre"> </span> <span style="white-space:pre"> </span>e.printStackTrace(); <span style="white-space:pre"> </span>System.out.println("sleep() Interrupted"); <span style="white-space:pre"> </span>}<span style="white-space:pre"> </span> <span style="white-space:pre"> </span>} <span style="white-space:pre"> </span> <span style="white-space:pre"> </span>public static void main(String[] args) throws Exception { <span style="white-space:pre"> </span>for(int i = 0 ; i < 3;i++){ <span style="white-space:pre"> </span>Thread daemons = new Thread(new SimpleDaemons()); <span style="white-space:pre"> </span>daemons.setDaemon(true); <span style="white-space:pre"> </span>daemons.start(); <span style="white-space:pre"> </span>} <span style="white-space:pre"> </span>System.out.println("daemons start!"); <span style="white-space:pre"> </span>TimeUnit.SECONDS.sleep(1); <span style="white-space:pre"> </span>} } /** * 校验守护线程中创建的线程是否是守护线程 * @author Administrator * */ class TestThread implements Runnable { <span style="white-space:pre"> </span>@Override <span style="white-space:pre"> </span>public void run() { <span style="white-space:pre"> </span>System.out.println("TestThread is Daemon:"+Thread.currentThread().isDaemon()); <span style="white-space:pre"> </span>} } 打印结果: 从打印结果观察到,在后台线程中创建的线程不是后台线程。 然后,我对代码进行了改造,加上while循环 代码如下: package com.hq.day0601; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; /** * 简单的后台线程(守护线程)练习,该练习主要演示的是后台线程在最后一个非后台线程结束后,也会被关闭 * @author Administrator * */ public class SimpleDaemons implements Runnable { @Override public void run() { try { ExecutorService exec = Executors.newCachedThreadPool(); exec.execute(new TestThread()); while(true){//添加while循环 TimeUnit.MILLISECONDS.sleep(100); System.out.println("SimpleDaemons is Daemons:"+Thread.currentThread().isDaemon()); System.out.println(Thread.currentThread() +" "+this ); } } catch (InterruptedException e) { e.printStackTrace(); System.out.println("sleep() Interrupted"); } } public static void main(String[] args) throws Exception { for(int i = 0 ; i < 3;i++){ Thread daemons = new Thread(new SimpleDaemons()); daemons.setDaemon(true); daemons.start(); } System.out.println("daemons start!"); TimeUnit.SECONDS.sleep(1); } } /** * 校验守护线程中创建的线程是否是守护线程 * @author Administrator * */ class TestThread implements Runnable { @Override public void run() { System.out.println("TestThread is Daemon:"+Thread.currentThread().isDaemon()); } } 我以为程序会在一秒后终止。但是却出了一个奇怪的现象,控制台一直在打印while循环里要打印的内容, 这让我感到非常费解,不知道有没有哪个大神讲解下这是什么原因。
java多线程中死循环问题
public class Test{ public static void main(String args[]){ MyThread thread=new MyThread(); thread.setName("张三"); thread.start(); while(thread.getStop()==false) {} System.out.println("我是主线程,负责恢复"+thread.getName()+"线程"); thread.restart(); //恢复thread线程 } } class MyThread extends Thread{ int number=0; boolean stop=false; boolean getStop(){ return stop; } public synchronized void run(){ while(true){ number++; System.out.println(Thread.currentThread().getName()+"的number="+number); if(number==3){ try{ System.out.println(Thread.currentThread().getName()+"被挂起"); stop=true; hangUP();//挂起线程 System.out.println(Thread.currentThread().getName()+"恢复执行"); } catch(Exception e){} } try{ Thread.sleep(1000); } catch(Exception e){} } } public synchronized void hangUP() throws InterruptedException{ wait(); } public synchronized void restart(){ notifyAll(); } } 为啥主函数里面死循环无法获取已经更改的thread.getStop()
线程跟main线程的关系
代码跟运行结果如下,本人只想知道main中的isAlive在t线程启动前为什么是死的, 在t线程启动后为什么是活的。两者有什么必然的联系呢。 ``` public class CountOperate extends Thread { public CountOperate() { System.out.println("CountOperate start"); System.out.println("Thread.currentThread().getName = " + Thread.currentThread().getName()); System.out.println("Thread.currentThread().isAlive = " + Thread.currentThread().isAlive()); System.out.println("this.getName = " + this.getName()); System.out.println("this.isAlive = " + this.isAlive()); System.out.println("CountOperate end"); } public void run() { System.out.println("run start"); System.out.println("Thread.currentThread().getName = " + Thread.currentThread().getName()); System.out.println("Thread.currentThread().isAlive = " + Thread.currentThread().isAlive()); System.out.println("this.getName = " + this.getName()); System.out.println("this.isAlive = " + this.isAlive()); System.out.println("run end"); } } ``` ``` public class ThreadTest { private static final long count = 10000001; public static void main(String[] args) throws InterruptedException { CountOperate c = new CountOperate(); Thread t = new Thread(c); System.out.println("main begin t isAlive = " + t.isAlive()); t.setName("A"); t.start(); System.out.println("main end t isAlive = " + t.isAlive()); } } ``` ## 运行结果 CountOperate start Thread.currentThread().getName = main Thread.currentThread().isAlive = true this.getName = Thread-0 this.isAlive = false CountOperate end ```main begin t isAlive = false``` run start ```main end t isAlive = true``` Thread.currentThread().getName = A Thread.currentThread().isAlive = true this.getName = Thread-0 this.isAlive = false run end
Java静态方法的线程安全性问题
如果多个线程同时访问同一个静态方法,后一个线程传递的参数值会覆盖前一个线程传递的参数值吗?代码示例如下: 被访问的静态资源: public class C { public static void test(String[] value) throws InterruptedException{ Thread.sleep(5000); System.out.println(Thread.currentThread().getId()); for(String v : value){ System.out.println(v); } } } 线程1: public class A { public static void main(String[] args) throws InterruptedException { C.test(new String[]{"A","B", "C"}); } } 线程2: public class B { public static void main(String[] args) throws InterruptedException { C.test(new String[]{"D","E", "F"}); } } 在线程1访问静态方法test并传递参数后,假设在执行中或执行之前,下一个线程2也访问了test方法并传递了新的参数,此时在线程1遍历参数时,会遍历到线程2传递的参数吗?
JAava多线程中遇到的一个问题
public class MyThread implements Runnable{ private int ticket = 50; public void run() { for(int i = 0;i<100;i++){ if(ticket>0){ try { Thread.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+ "线程,ticket = "+(ticket--)); } } } } public class SyncDemo { public static void main(String[] args) { // MyThread mt = new MyThread(); // Thread t1 = new Thread(mt,"线程A"); // Thread t2 = new Thread(mt,"线程B"); // Thread t3 = new Thread(mt,"线程C"); // t1.start(); // t2.start(); // t3.start(); new Thread(new MyThread(),"线程A").start(); new Thread(new MyThread(),"线程B").start(); new Thread(new MyThread(),"线程c").start(); } } 为什么采用注释的方式票数最后为负数,而采用非注释的方式则不会出现票数为负数的情况
Java多线程中断的问题
代码如下,为什么在中断之后将中断位清除后再进入阻塞,仍然会捕捉到中断异常? ``` public class InterruptDemo implements Runnable { public void run() { try { //中断当前线程 Thread.currentThread().interrupt(); boolean b = Thread.interrupted(); System.out.println(b); //true b = Thread.interrupted(); System.out.println(b); //false //进入阻塞 Thread.currentThread().wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } ```
java中this和Thread.currentThread()区别,见下代码
public class hello extends Thread { public hello(String name){ super(name); System.out.println("Thread.currentThread().getname()="+Thread.currentThread().getName()); System.out.println("This.getName="+this.getName()); } public void run(){ System.out.println("Thread.currentThread().getname()="+Thread.currentThread().getName()); System.out.println("This.getName="+this.getName()); } public static void main(String[] args){ Thread t1=new Thread(new hello("A")); t1.setName("B"); t1.start(); } } 得到Thread.currentThread().getname()=main This.getName=A Thread.currentThread().getname()=B This.getName=A 为什么会得到B和A不一样的名字
终于明白阿里百度这样的大公司,为什么面试经常拿ThreadLocal考验求职者了
点击上面↑「爱开发」关注我们每晚10点,捕获技术思考和创业资源洞察什么是ThreadLocalThreadLocal是一个本地线程副本变量工具类,各个线程都拥有一份线程私有的数
程序员必须掌握的核心算法有哪些?
由于我之前一直强调数据结构以及算法学习的重要性,所以就有一些读者经常问我,数据结构与算法应该要学习到哪个程度呢?,说实话,这个问题我不知道要怎么回答你,主要取决于你想学习到哪些程度,不过针对这个问题,我稍微总结一下我学过的算法知识点,以及我觉得值得学习的算法。这些算法与数据结构的学习大多数是零散的,并没有一本把他们全部覆盖的书籍。下面是我觉得值得学习的一些算法以及数据结构,当然,我也会整理一些看过...
《奇巧淫技》系列-python!!每天早上八点自动发送天气预报邮件到QQ邮箱
此博客仅为我业余记录文章所用,发布到此,仅供网友阅读参考,如有侵权,请通知我,我会删掉。 补充 有不少读者留言说本文章没有用,因为天气预报直接打开手机就可以收到了,为何要多此一举发送到邮箱呢!!!那我在这里只能说:因为你没用,所以你没用!!! 这里主要介绍的是思路,不是天气预报!不是天气预报!!不是天气预报!!!天气预报只是用于举例。请各位不要再刚了!!! 下面是我会用到的两个场景: 每日下
面试官问我:什么是消息队列?什么场景需要他?用了会出现什么问题?
你知道的越多,你不知道的越多 点赞再看,养成习惯 GitHub上已经开源 https://github.com/JavaFamily 有一线大厂面试点脑图、个人联系方式,欢迎Star和完善 前言 消息队列在互联网技术存储方面使用如此广泛,几乎所有的后端技术面试官都要在消息队列的使用和原理方面对小伙伴们进行360°的刁难。 作为一个在互联网公司面一次拿一次Offer的面霸,打败了无数
8年经验面试官详解 Java 面试秘诀
    作者 | 胡书敏 责编 | 刘静 出品 | CSDN(ID:CSDNnews) 本人目前在一家知名外企担任架构师,而且最近八年来,在多家外企和互联网公司担任Java技术面试官,前后累计面试了有两三百位候选人。在本文里,就将结合本人的面试经验,针对Java初学者、Java初级开发和Java开发,给出若干准备简历和准备面试的建议。   Java程序员准备和投递简历的实
究竟你适不适合买Mac?
我清晰的记得,刚买的macbook pro回到家,开机后第一件事情,就是上了淘宝网,花了500元钱,找了一个上门维修电脑的师傅,上门给我装了一个windows系统。。。。。。 表砍我。。。 当时买mac的初衷,只是想要个固态硬盘的笔记本,用来运行一些复杂的扑克软件。而看了当时所有的SSD笔记本后,最终决定,还是买个好(xiong)看(da)的。 已经有好几个朋友问我mba怎么样了,所以今天尽量客观
程序员一般通过什么途径接私活?
二哥,你好,我想知道一般程序猿都如何接私活,我也想接,能告诉我一些方法吗? 上面是一个读者“烦不烦”问我的一个问题。其实不止是“烦不烦”,还有很多读者问过我类似这样的问题。 我接的私活不算多,挣到的钱也没有多少,加起来不到 20W。说实话,这个数目说出来我是有点心虚的,毕竟太少了,大家轻喷。但我想,恰好配得上“一般程序员”这个称号啊。毕竟苍蝇再小也是肉,我也算是有经验的人了。 唾弃接私活、做外
大学四年自学走来,这些珍藏的「实用工具/学习网站」我全贡献出来了
知乎高赞:文中列举了互联网一线大厂程序员都在用的工具集合,涉及面非常广,小白和老手都可以进来看看,或许有新收获。
《阿里巴巴开发手册》读书笔记-编程规约
Java编程规约命名风格 命名风格 类名使用UpperCamelCase风格 方法名,参数名,成员变量,局部变量都统一使用lowerCamelcase风格 常量命名全部大写,单词间用下划线隔开, 力求语义表达完整清楚,不要嫌名字长 ...
Python爬虫爬取淘宝,京东商品信息
小编是一个理科生,不善长说一些废话。简单介绍下原理然后直接上代码。 使用的工具(Python+pycharm2019.3+selenium+xpath+chromedriver)其中要使用pycharm也可以私聊我selenium是一个框架可以通过pip下载 pip install selenium -i https://pypi.tuna.tsinghua.edu.cn/simple/ 
阿里程序员写了一个新手都写不出的低级bug,被骂惨了。
你知道的越多,你不知道的越多 点赞再看,养成习惯 本文 GitHub https://github.com/JavaFamily 已收录,有一线大厂面试点思维导图,也整理了很多我的文档,欢迎Star和完善,大家面试可以参照考点复习,希望我们一起有点东西。 前前言 为啥今天有个前前言呢? 因为你们的丙丙啊,昨天有牌面了哟,直接被微信官方推荐,知乎推荐,也就仅仅是还行吧(心里乐开花)
Java工作4年来应聘要16K最后没要,细节如下。。。
前奏: 今天2B哥和大家分享一位前几天面试的一位应聘者,工作4年26岁,统招本科。 以下就是他的简历和面试情况。 基本情况: 专业技能: 1、&nbsp;熟悉Sping了解SpringMVC、SpringBoot、Mybatis等框架、了解SpringCloud微服务 2、&nbsp;熟悉常用项目管理工具:SVN、GIT、MAVEN、Jenkins 3、&nbsp;熟悉Nginx、tomca
Python爬虫精简步骤1 获取数据
爬虫的工作分为四步: 1.获取数据。爬虫程序会根据我们提供的网址,向服务器发起请求,然后返回数据。 2.解析数据。爬虫程序会把服务器返回的数据解析成我们能读懂的格式。 3.提取数据。爬虫程序再从中提取出我们需要的数据。 4.储存数据。爬虫程序把这些有用的数据保存起来,便于你日后的使用和分析。 这一篇的内容就是:获取数据。 首先,我们将会利用一个强大的库——requests来获取数据。 在电脑上安装
Python绘图,圣诞树,花,爱心 | Turtle篇
1.画圣诞树 import turtle screen = turtle.Screen() screen.setup(800,600) circle = turtle.Turtle() circle.shape('circle') circle.color('red') circle.speed('fastest') circle.up() square = turtle.Turtle()
作为一个程序员,CPU的这些硬核知识你必须会!
CPU对每个程序员来说,是个既熟悉又陌生的东西? 如果你只知道CPU是中央处理器的话,那可能对你并没有什么用,那么作为程序员的我们,必须要搞懂的就是CPU这家伙是如何运行的,尤其要搞懂它里面的寄存器是怎么一回事,因为这将让你从底层明白程序的运行机制。 随我一起,来好好认识下CPU这货吧 把CPU掰开来看 对于CPU来说,我们首先就要搞明白它是怎么回事,也就是它的内部构造,当然,CPU那么牛的一个东
破14亿,Python分析我国存在哪些人口危机!
2020年1月17日,国家统计局发布了2019年国民经济报告,报告中指出我国人口突破14亿。 猪哥的朋友圈被14亿人口刷屏,但是很多人并没有看到我国复杂的人口问题:老龄化、男女比例失衡、生育率下降、人口红利下降等。 今天我们就来分析一下我们国家的人口数据吧! 更多有趣分析教程,扫描下方二维码关注vx公号「裸睡的猪」 即可查看! 一、背景 1.人口突破14亿 2020年1月17日,国家统计局发布
听说想当黑客的都玩过这个Monyer游戏(1~14攻略)
第零关 进入传送门开始第0关(游戏链接) 请点击链接进入第1关: 连接在左边→ ←连接在右边 看不到啊。。。。(只能看到一堆大佬做完的留名,也能看到菜鸡的我,在后面~~) 直接fn+f12吧 &lt;span&gt;连接在左边→&lt;/span&gt; &lt;a href="first.php"&gt;&lt;/a&gt; &lt;span&gt;←连接在右边&lt;/span&gt; o
在家远程办公效率低?那你一定要收好这个「在家办公」神器!
相信大家都已经收到国务院延长春节假期的消息,接下来,在家远程办公可能将会持续一段时间。 但是问题来了。远程办公不是人在电脑前就当坐班了,相反,对于沟通效率,文件协作,以及信息安全都有着极高的要求。有着非常多的挑战,比如: 1在异地互相不见面的会议上,如何提高沟通效率? 2文件之间的来往反馈如何做到及时性?如何保证信息安全? 3如何规划安排每天工作,以及如何进行成果验收? ......
作为一个程序员,内存和磁盘的这些事情,你不得不知道啊!!!
截止目前,我已经分享了如下几篇文章: 一个程序在计算机中是如何运行的?超级干货!!! 作为一个程序员,CPU的这些硬核知识你必须会! 作为一个程序员,内存的这些硬核知识你必须懂! 这些知识可以说是我们之前都不太重视的基础知识,可能大家在上大学的时候都学习过了,但是嘞,当时由于老师讲解的没那么有趣,又加上这些知识本身就比较枯燥,所以嘞,大家当初几乎等于没学。 再说啦,学习这些,也看不出来有什么用啊!
别低估自己的直觉,也别高估自己的智商
所有群全部吵翻天,朋友圈全部沦陷,公众号疯狂转发。这两周没怎么发原创,只发新闻,可能有人注意到了。我不是懒,是文章写了却没发,因为大家的关注力始终在这次的疫情上面,发了也没人看。当然,我...
这个世界上人真的分三六九等,你信吗?
偶然间,在知乎上看到一个问题 一时间,勾起了我深深的回忆。 以前在厂里打过两次工,做过家教,干过辅导班,做过中介。零下几度的晚上,贴过广告,满脸、满手地长冻疮。   再回首那段岁月,虽然苦,但让我学会了坚持和忍耐。让我明白了,在这个世界上,无论环境多么的恶劣,只要心存希望,星星之火,亦可燎原。   下文是原回答,希望能对你能有所启发。   如果我说,这个世界上人真的分三六九等,
为什么听过很多道理,依然过不好这一生?
记录学习笔记是一个重要的习惯,不希望学习过的东西成为过眼云烟。做总结的同时也是一次复盘思考的过程。 本文是根据阅读得到 App上《万维钢·精英日课》部分文章后所做的一点笔记和思考。学习是一个系统的过程,思维模型的建立需要相对完整的学习和思考过程。以下观点是在碎片化阅读后总结的一点心得总结。
B 站上有哪些很好的学习资源?
哇说起B站,在小九眼里就是宝藏般的存在,放年假宅在家时一天刷6、7个小时不在话下,更别提今年的跨年晚会,我简直是跪着看完的!! 最早大家聚在在B站是为了追番,再后来我在上面刷欧美新歌和漂亮小姐姐的舞蹈视频,最近两年我和周围的朋友们已经把B站当作学习教室了,而且学习成本还免费,真是个励志的好平台ヽ(.◕ฺˇд ˇ◕ฺ;)ノ 下面我们就来盘点一下B站上优质的学习资源: 综合类 Oeasy: 综合
如何优雅地打印一个Java对象?
你好呀,我是沉默王二,一个和黄家驹一样身高,和刘德华一样颜值的程序员。虽然已经写了十多年的 Java 代码,但仍然觉得自己是个菜鸟(请允许我惭愧一下)。 在一个月黑风高的夜晚,我思前想后,觉得再也不能这么蹉跎下去了。于是痛下决心,准备通过输出的方式倒逼输入,以此来修炼自己的内功,从而进阶成为一名真正意义上的大神。与此同时,希望这些文章能够帮助到更多的读者,让大家在学习的路上不再寂寞、空虚和冷。 ...
雷火神山直播超两亿,Web播放器事件监听是怎么实现的?
Web播放器解决了在手机浏览器和PC浏览器上播放音视频数据的问题,让视音频内容可以不依赖用户安装App,就能进行播放以及在社交平台进行传播。在视频业务大数据平台中,播放数据的统计分析非常重要,所以Web播放器在使用过程中,需要对其内部的数据进行收集并上报至服务端,此时,就需要对发生在其内部的一些播放行为进行事件监听。 那么Web播放器事件监听是怎么实现的呢? 01 监听事件明细表 名
3万字总结,Mysql优化之精髓
本文知识点较多,篇幅较长,请耐心学习 MySQL已经成为时下关系型数据库产品的中坚力量,备受互联网大厂的青睐,出门面试想进BAT,想拿高工资,不会点MySQL优化知识,拿offer的成功率会大大下降。 为什么要优化 系统的吞吐量瓶颈往往出现在数据库的访问速度上 随着应用程序的运行,数据库的中的数据会越来越多,处理时间会相应变慢 数据是存放在磁盘上的,读写速度无法和内存相比 如何优化 设计
Linux 命令(122)—— watch 命令
1.命令简介 2.命令格式 3.选项说明 4.常用示例 参考文献 [1] watch(1) manual
Linux 命令(121)—— cal 命令
1.命令简介 2.命令格式 3.选项说明 4.常用示例 参考文献 [1] cal(1) manual
记jsp+servlet+jdbc实现的新闻管理系统
1.工具:eclipse+SQLyog 2.介绍:实现的内容就是显示新闻的基本信息,然后一个增删改查的操作。 3.数据库表设计 列名 中文名称 数据类型 长度 非空 newsId 文章ID int 11 √ newsTitle 文章标题 varchar 20 √ newsContent 文章内容 text newsStatus 是否审核 varchar 10 news...
Python新型冠状病毒疫情数据自动爬取+统计+发送报告+数据屏幕(三)发送篇
今天介绍的项目是使用 Itchat 发送统计报告 项目功能设计: 定时爬取疫情数据存入Mysql 进行数据分析制作疫情报告 使用itchat给亲人朋友发送分析报告(本文) 基于Django做数据屏幕 使用Tableau做数据分析 来看看最终效果 目前已经完成,预计2月12日前更新 使用 itchat 发送数据统计报告 itchat 是一个基于 web微信的一个框架,但微信官方并不允
相关热词 c#如何定义数组列表 c#倒序读取txt文件 java代码生成c# c# tcp发送数据 c#解决时间格式带星期 c#类似hashmap c#设置istbox的值 c#获取多线程返回值 c# 包含数字 枚举 c# timespan
立即提问