继承Thread方法创建和使用线程

继承java.lang.Thread类完成
具体代码如下：

class  music extends Thread{//Thread是线程类，music继承它也是线程类
@Override
public void run() {
for(int i=0;i<200;i++)
{
System.out.println("放歌");
}
}
public static void main(String[] args) {
music s=new music();
s.start();
for(int i=0;i<200;i++)
{
System.out.println("打游戏");
}
}
}

注意：
1.启动进程时并没有调用run方法，底层会自动调用，重写Thread中的方 法，快捷键ALT+INS。
2.注意启动线程要在前边写，否则打完游戏了歌还没开始执行。
3.注意启动线程不能调用run方法名称，而应该用start启动。

使用Runnable方式创建和启动线程

实现Runnable接口来完成

class Music implements Runnable {//Music不是线程类是实现类
@Override
public void run() {
for (int i = 0; i < 200; i++) {
System.out.println("播放音乐");
}
}
}
class playgame{
public static void main(String[] args) {
new Thread(new Music()).start();/*

for(int i=0;i<200;i++){
System.out.println("打游戏");
}
}
}

注意：
1.因为Music不是线程类，所以不能创建其对象来启动线程，而需要用Thread的接受实现Runnable的类多为对象的构造方法来启动线程。
2.注意启动线程要在前边写，否则打完游戏了歌还没开始执行。
3.注意启动线程不能调用run方法名称，而应该用start启动。
后两点与继承Thread方法类似

继承方式和实现方式对比

代码如下：

class Students extends Thread{
static int nums=100;
public Students(String name) {
super(name);//将name存向父类中
}
@Override
public void run(){
for(int i=nums;i>0;i--) {
if (nums > 0) {
System.out.println(this.getName() + "拿走第" + i + "个苹果");
}
}
}
}
//实现方式
class Students1 implements Runnable{
@Override
public void run() {
for(int i=Students.nums;i>0;i--)
{
System.out.println(Thread.currentThread().getName()+"拿走第"+i+"个苹果");
}//此时是实现Runnable来创建线程，不能直接用getName方法来获取名字，要先获取当  前线程，要用Thread.currentThread()
}
}
public class 继承方式与实现方式对比 {
public static void main(String[] args)  {
/* new Students("A").start();//传递名字要在类中写构造方法将名字传给父类
new Students("B").start();
new Students("C").start();*/
Students1 a=new Students1();
new Thread(a,"D").start();//实现方法可以完成资源共享，因为存在这样的构造方法可以将对象传入
new Thread(a,"E").start();
new Thread(a,"F").start();
}
}

分析代码可知：
1.两者都可完成基本功能，但若想完成资源共享必须使用实现Runnable接口来实现。
2.在java中类是单继承的，继承Thread后就不能再继承其他类，但java中却可以实现多接口，及实现Runnable接口后还可以实现其他接口并且继承其他类。
3.继承Thread类相比较起来简单些。
4.推荐使用实现Runnable来完成线程的创建和使用，若要完成资源共享或者继承其他类则只能用实现Runnable来实现。

线程并发导致的安全问题

线程并发所导致的安全问题主要是因为多个线程同时共享一块资源所导致的问题，因为线程调度很快，所以可能出现同一资源被使用了两次的情况，可以模拟网络延迟使用Thread.sleep()来使线程安全问题更加明显。
代码如下：

class Apple1 implements Runnable{
int j=100;
public void run(){
for(int i=100;i>0;i--) {
if (j > 0){
try {
Thread.sleep(150);
} catch (InterruptedException e) {
e.printStackTrace(
);
System.out.println(Thread.currentThread().getName() + "拿走了第" + j-- + "个苹果");
}
}
}
}
}
class Student {
public static void main(String[] args) {
Apple1 a=new Apple1();
new Thread(a,"E").start();
new Thread(a,"F").start();
new Thread(a,"G").start();
}
}

执行此代码有时就会出现问题，解决该问题的方法有三种：
1.同步代码块
2.同步方法
3.Lock机制

同步代码块

class Apple1 implements Runnable{
int j=100;
public void run(){
for(int i=100;i>0;i--) {
synchronized (this) {
if (j > 0){
try {
Thread.sleep(150);
} catch (InterruptedException e) {
e.printStackTrace(
);
}
System.out.println(Thread.currentThread().getName() + "拿走了第" + j-- + "个苹果");
}
}
}
}
}
class Student {
public static void main(String[] args) {
Apple1 a=new Apple1();
new Thread(a,"E").start();
new Thread(a,"F").start();
new Thread(a,"G").start();
}
}

同步方法

代码如下：

class Apple2 implements Runnable{
int i=100;
@Override
public void run() {
for(int j=i;j>0;j--)
{
dowork();
}
}
public synchronized  void dowork() {
if (i > 0) {//注意这个if的重要性
System.out.println(Thread.currentThread().getName() + "拿走了第" + i + "个苹果");
i--;
}
}
public static void main(String[] args) {
Apple2 q= new Apple2();
new Thread(q,"A").start();
new Thread(q,"B").start();
new Thread(q,"C").start();
}

}

Lock机制

代码如下：

import java.util.concurrent.locks.ReentrantLock;
class Apple3 implements Runnable{
int i=100;
private final ReentrantLock Lock=new ReentrantLock();//创建锁对象
@Override
public void run() {
for(int j=100;j>0;j++){
dowork1();
}
}
public void dowork1() {
Lock.lock();//获取锁
try {
if (i > 0) {
System.out.println(Thread.currentThread().getName() + "拿走了第" + i + "个苹果");
i--;
}
}finally{
Lock.unlock();//释放锁
}
}
public static void main(String[] args) {
Apple3 s=new Apple3();
new  Thread(s,"A").start();
new  Thread(s,"B").start();
new  Thread(s,"C").start();
}
}

使用锁机制主要是创建所对象获取锁释放锁这几步，当一个线程获取锁时其他线程不能进入到该带代码块中，可以防止线程安全问题。