多线程的基本操作方法

多线程的所有操作方法基本上都在Thread类之中定义的，所以研究方法也就是Threa类的翻译，看主要三组方法。

1.线程的命名和取得

在整个多线程的操作之中，名称是最重要的，因为多线程的运行状态是不确定的，那么系统只能够根据名字来判断出是哪一个线程，线程命名的时候不要有重复，更不要修改。
在Thread类提供了如下的几个方法进行名称操作：
构造方法：public Thread(Runnable target,String name)
设置名字：public final void setName(String name)
取得名字 ：public final String getName()
问题是线程的运行状态不确定，所以要想取得线程的名字，只能够取得当前正在执行的线程。
那么在这样情况下要想取得当前的线程对象，就必须依靠Thread类的方法:
public static Thread currentThread()
范例：取得当前名字
package thread;
class MyThr implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
public class Threade {
public static void main(String[] args) {
// TODO Auto-generated method stub
MyThr mt=new MyThr();
new Thread(mt).start();
new Thread(mt).start();
new Thread(mt,"带名字").start();
}
}
发现此时如果设置了线程名称，那么就返回设置的数据，如果没有设置线程名字会自动的进行命名，以保证每一个线程一定有一个名字。（存在static命名）
范例：观察下面代码
package thread;
class MyThre implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
public class Threadea {
public static void main(String[] args) {
// TODO Auto-generated method stub
MyThre mt=new MyThre();
new Thread(mt,"自定义线程").start();
mt.run();
}
}
现在发现通过“mt.run();”执行的时候取得的 线程名称是main，所以可以得出结论：主方法也是一个线程，而新得问题出现了，线程依附于进程，而进程在那里？
每当用户使用java命令解释一个类的时候，对操作系统而言，都会默认启动一个java的进程，而主方法只是这进程之中的一个线程而已。
问题：每一个JVM运行时至少启动几个线程昵？
至少启动两个线程：主线程和GC垃圾回收线程


线程的休眠
线程的休眠指的是让程序暂缓， 休眠方法：public static void sleep(long millis) throwsInteruptedException 
范例：观察休眠
package thread;
class MyThrea implements Runnable{
@Override
public void run() {//线程的主方法
for(int x=0;x<100;x++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"x="+x);
}
}
}
public class Threadf {
public static void main(String[] args) {
// TODO Auto-generated method stub
MyThrea mt=new MyThrea();
new Thread(mt,"线程A:").start();
new Thread(mt,"线程B:").start();
new Thread(mt,"线程C:").start();
new Thread(mt,"线程D:").start();
new Thread(mt,"线程E:").start();
}


}
由于线程资源的间隔太短，那么可以简单理解为： 多个线程有可能会同时进入到方法执行。


线程的优先级
从理论上讲线程的优先级越高，越有可能先执行，但这也是只是可能，如果要想进行线程的优先级操作，可以使用如下的两个方法：
设置优先级：public final void setPriority(int newPriority)
取得优先级：public final int getPriority()
对于优先级在Thread类之中定义了三个常量：
最高优先级：public static final int MAX_PRIORITY  ,10；
中等优先级：public static final int NORM_PRIORITY  ,5：
最低优先级：public static final int MIN_PRIORITY   ,1：
范例：观察优先级改变
package thread;
class My implements Runnable{
@Override

public void run() {
for(int x=0;x<20;x++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"x="+x);
}
}
}
public class Threadfa {
public static void main(String[] args) {
// TODO Auto-generated method stub
My mt=new My();
Thread t1=new Thread(mt,"线程A:");
Thread t2=new Thread(mt,"线程B:");
Thread t3=new Thread(mt,"线程C:");
t1.setPriority(Thread.MAX_PRIORITY);
t3.setPriority(Thread.MIN_PRIORITY);
t1.start();
t2.start();
t3.start();
}
}
问题;请问主线程的优先级时多少昵？
5，主线程只是个中等优先级
package thread;
class My implements Runnable{
@Override
public void run() {
for(int x=0;x<20;x++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"x="+x);
}
}
}
public class Threadfa {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(Thread.currentThread().getPriority());
}
}


线程的同步与死锁
1.线程的同步
当多个线程访问同一资源的时候一定需要考虑到同步问题，那么下面通过一个卖票程序，观察不同步的问题
package thread;
class Mya implements Runnable{
private int ticket=8;//一共8张票
@Override
public void run() { //线程的主方法
for(int x=0;x<20;x++) {
if(this.ticket>0) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+",ticket="+this.ticket--);
}
}
}
}
public class Threadg {
public static void main(String[] args) {
// TODO Auto-generated method stub
Mya mt=new Mya();
new Thread(mt,"票贩子A").start();
new Thread(mt,"票贩子B").start();
new Thread(mt,"票贩子C").start();
new Thread(mt,"票贩子D").start();
new Thread(mt,"票贩子E").start();
new Thread(mt,"票贩子F").start();
}
}
那么在这个时候就发生了不同步的情况，而发生的原因也很简单，对于整个买票过程实际上时两步完成的
第一步：使用if语句是否有票：
第二步：进行票数的修改
此时可能出现这种情况，如果说现在只有最后一张票了，可以满足if条件判断，所以线程可以通过if语句拦截，可是在修改票之前出现一个延迟操作，那么有可能在这个延迟的过程之中，又出现其它线程进入到方法之中，由于此时没有修改票数，那么这个线程也可以满足if条件判断，后面的线程依次类推，所以当休眠时间一过，进行票数修改的时候，都将在已有的票数上修改，自然会出现负数。
问题的解决关键是需要一把锁。
如果要想上好这把“锁”，则可以采用两种方式完成：同步代码块，同步方法
范例：使用同步代码块
同步代码块式使用synchronized关键字定义的代码块，但是在进行同步的时候一定要设置好一个同步对象，所以同步对象一般使用当前对象this表示
package thread;
class Myb implements Runnable{
private int ticket=8;//一共8张票
@Override
public void run() { //线程的主方法
for(int x=0;x<20;x++) {
synchronized(this) {
if(this.ticket>0) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+",ticket="+this.ticket--);
}
}
  } 
}
}
public class Threadga {
public static void main(String[] args) {
// TODO Auto-generated method stub
Myb mt=new Myb();
new Thread(mt,"票贩子A").start();
new Thread(mt,"票贩子B").start();
new Thread(mt,"票贩子C").start();
new Thread(mt,"票贩子D").start();
new Thread(mt,"票贩子E").start();
new Thread(mt,"票贩子F").start();
}


}
此时的程序执行速度变得明显缓慢了，因为需要一个个排队进行。虽然性能变慢了，但是数据的安全性提高了，也就是说异步处理（不加synchronized）和同步处理（使用synchronized）的区别也在于此。
范例：同步方法实现
如果在一个方法的声明上使用了synchronized关键字，则表示此方法式一个同步方法。
package thread;
class Myc implements Runnable{
private int ticket=8;//一共8张票
@Override
public void run() {
for(int x=0;x<20;x++) {
this.sale();
}
}
public synchronized void sale() {
if(this.ticket>0) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+",ticket="+this.ticket--);
  }
}
}
public class Threadgb {
public static void main(String[] args) {
// TODO Auto-generated method stub
Myc mt=new Myc();
new Thread(mt,"票贩子A").start();
new Thread(mt,"票贩子B").start();
new Thread(mt,"票贩子C").start();
new Thread(mt,"票贩子D").start();
new Thread(mt,"票贩子E").start();
new Thread(mt,"票贩子F").start();
}
}
同步的核心意义：一个线程要等待另一个线程执行完毕。


死锁（看懂结论）
//下面代码只是演示死锁出现的状况，当代码本身没有意义
所谓的死锁就是指的互相等待的情况
结论：多个线访问同一资源的时候一定考虑到线程的同步，但是同步会影响程序的性能，同时会提升数据的安全性，过多的同步会有可能出现死锁。