常用的方法！
1：Thread.setName(String name);设置当前线程的名字。
2：Thread.currentThread();返回当前正在执行的线程对象的引用。
3：Thread.getName();返回当前线程的名字。
4：isAlive();判断线程是否还活着。
5：getPriority()：获得线程的优先级数值。
6：setPriority()：设置线程的优先级数值。
7：Thread.sleep(XXX)：设置当前线程休眠时间。
8：join()：当前线程调用某个线程的join()方法，将当前线程和该线程“合并”，直到该线程结束，当前线程才会恢复运行。。
9：yield()：让出CPU，当前线程进入就绪队列等待调度。
如下示例代码：
/**
* 创建一个类实现Runnable接口
* @author Liao
*
*/
class A implements Runnable{
@Override
public void run() {
for (int i=0; i<10; i++){
System.out.printf("%s线程被调用了\n" ,Thread.currentThread().getName());
}
}
}
public class ThreadTest2 {
public static void main(String[] args) {
/*创建A的对象*/
A a = new A();
/*利用a构建Thread的对象*/
Thread thread = new Thread(a);
/*为线程设置名称*/
thread.setName("习近平");
/*启动线程*/
thread.start();
for (int i=0; i<10;i++){
System.out.printf("%s线程被调用了\n" ,Thread.currentThread().getName());
}
}
}
线程的优先级：
1：线程的优先级用数字来表示，范围从1到10。
2：主线程的缺省优先级是5，子线程的优先级默认与其父线程相同。
3：通常高优先级的线程将先于低优先级的线程执行，但并不总是这样(此时还只是处于就绪状态),因此实际开发中不可依赖优先级来决定线程的执行次序。
示例代码：
class A implements Runnable{
@Override
public void run() {
for (int i=0; i<10; i++){
System.out.println("A线程" + i);
}
}
}
class B implements Runnable{
@Override
public void run() {
for (int i=0; i<10; i++){
System.out.println("B线程" + i);
}
}
}
public class ThreadTest2 {
public static void main(String[] args) {
/*创建A的对象*/
A a = new A();
/*创建B的对象*/
B b = new B();
/*利用a构建Thread的对象*/
Thread thread1 = new Thread(a);
/*利用b构建Thread的对象*/
Thread thread2 = new Thread(b);
/*设置线程b的优先级为6*/
thread2.setPriority(Thread.NORM_PRIORITY + 1);
/*启动线程a*/
thread1.start();
/*启动线程b*/
thread2.start();
}
}
程序运行结果：
从图中可以看出，即使线程B的优先级高于A但是仍然有可能先执行A线程。
线程休眠！
线程的休眠指的是暂停执行当前运行中的线程，使之进入阻塞状态，待经过指定的"延迟时间"后再醒来并转为就绪状态。
示例代码：
class A implements Runnable{
@Override
public void run() {
for (int i=0; i<10; i++){
System.out.println("A线程" + i);
/*使线程休眠*/
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class ThreadTest2 {
public static void main(String[] args) {
/*创建A的对象*/
A a = new A();
/*利用a构建Thread的对象*/
Thread thread1 = new Thread(a);
/*启动线程a*/
thread1.start();
}
}
线程的让步是指线程在运行中主动放弃当前获得的CPU处理机会，给其他线程执行的机会，但不使该线程阻塞，而是使之转为就绪状态。
示例代码：
class A implements Runnable{
@Override
public void run() {
for (int i=0; i<10; i++){
System.out.println(Thread.currentThread().getName() +":"+ i);
if (i % 10 == 0){
/*使线程让步*/
Thread.yield();
}
}
}
}
public class ThreadTest2 {
public static void main(String[] args) {
/*创建A的对象*/
A a = new A();
/*利用a构建Thread的对象1*/
Thread thread1 = new Thread(a);
/*利用a构建Thread的对象2*/
Thread thread2 = new Thread(a);
/*设置名称*/
thread1.setName("线程A");
thread1.setName("线程B");
/*启动*/
thread1.start();
thread2.start();
}
}
线程的串行化是指在多线程程序中，如果在一个线程运行的过程中要用到另外一个线程的运行结果，则可以进行线程的串行化处理。
class A implements Runnable{
@Override
public void run() {
for (int i=0; i<50; i++){
System.out.println("子线程：" + i);
}
}
}
public class ThreadTest2 {
public static void main(String[] args) {
/*创建A的对象*/
A a = new A();
/*利用a构建Thread的对象*/
Thread thread = new Thread(a);
/*启动*/
thread.start();
try {
/*暂停当前正在执行thread.join()的线程即主线程，直到thread对应的线程运行终止之后，当前线程才会恢复*/
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i=0; i<50; i++){
System.out.println("主线程:" + i);
}
}
}