Java知识总结-多线程

说明：关于多线程，同步问题是我有待加强的知识点。

一、线程的创建。

创建线程可以通过两种方式：

方式一，自定义一个类，继承Thread类并重写run（）方法。例：

//自定义类继承Thread类
class MyThread extends Thread{
//重写run()方法
public void run(){
System.out.println("重写run()方法");
}
}
public class Test {
public static void main(String[] args){
//创建Thread子类对象
MyThread mt=new MyThread();
//通过调用start()方法，开启新线程，同时执行run()方法
mt.start();
}
}

方式二，自定义一个类，实现Runnable接口。

//自定义类实现Runnable接口
class MyClass implements Runnable{
//重写run()方法
public void run(){
System.out.println("重写run()方法");
}
}
public class Test {
public static void main(String[] args){
//创建Runnable子类对象
MyClass mc=new MyClass();
//将对象作为参数传入Thread的构造函数，创建Thread类对象
Thread t=new Thread(mc);
//通过调用Thread类的start()方法，开启新线程，同时执行run()方法
t.start();
}
}

上面创建线程的两种方式里，方式二可以避免Java中单继承的问题，当一个类有父类时，可以通过实现Runnable接口来定义线程。

二，线程的操作

在Thread类中，有些常见的操作线程的方法。

------getName()：返回该线程的名称，返回值类型：String。

//自定义类实现Runnable接口
class MyClass implements Runnable{
//重写run()方法
public void run(){
System.out.println("重写run()方法");
}
}
public class Test {
public static void main(String[] args){
//创建Runnable子类对象
MyClass mc=new MyClass();
//将对象作为参数传入Thread的构造函数，创建Thread类对象
Thread t=new Thread(mc);
//获取线程名称
System.out.println(t.getName());
}
}

运行结果：

Thread-0

这时返回的线程名称是系统默认的名称，也可以通过getName()方法自定义线程的名称。

------setName(String name):改变线程名称，使之与参数name相同。

//自定义类实现Runnable接口
class MyClass implements Runnable{
//重写run()方法
public void run(){
System.out.println("重写run()方法");
}
}
public class Test {
public static void main(String[] args){
//创建Runnable子类对象
MyClass mc=new MyClass();
//将对象作为参数传入Thread的构造函数，创建Thread类对象
Thread t=new Thread(mc);
//自定义线程名称
t.setName("自定义线程 Myclass");
//获取线程名称
System.out.println(t.getName());
}
}

运行结果：

自定义线程 Myclass

这时线程的名称就变为我们设置的名字。

------sleep(long millis)：使正在执行的线程休眠（暂停执行），返回值类型：void;静态方法。

注，该方法已经声明异常，当我们在run()方法内调用sleep()时，需要对异常已经处理，因为Thread类中的run()方法并没有抛出异常，所以重写run()时也不可以抛出异常，只能对异常进行try{}catch{}处理。

class MyClass extends Thread{
public void run(){
for(int x=0;x<100;x++){
try {
//使线程休眠20毫秒
sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName());
}
}
}

-------wait():使当前线程等待。返回值类型：void；

注：如果当前线程被wait()方法操作导致等待时，该线程会自动放弃在CPU中的执行权和执行资格，系统CPU会随机执行其他具备执行资格的线程。

class MyClassA extends Thread{
public void run(){

for(int x=0;x<100;x++){

try {
if(x==10)
//使线程等待
wait();
} catch (InterruptedException e) {
//异常处理
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName());
}
}
}

------notify():唤醒与当前线程同步的线程中的单个等待线程；

------notifyAll():唤醒与当前线程同步的线程中的所有等待线程;

------interrupt():中断线程的休眠和等待状态，使线程继续运行。

------join():等待该调用线程执行完毕后，原线程继续执行。

------setDaemon():将该线程标记为守护线程，当主线程运行结束时，守护线程随之结束。

------setPriority(int newPriority):更改线程的优先级。

------yiekd(): 暂停当前线程，并执行其他线程。

三，同步

当多个线程共享同一资源时，

同步的前提：

1.必须要有两个或者两个以上的线程；

2.必须是多个线程使用同一个锁。

同步的作用：通过同步是多个线程只能有一个线程在运行，

好处：解决了多线程的安全问题；

弊端：多个线程需要判断锁，较为消耗资源。

同步实例：

例1：简单的同步代码块结构

class MyClass implements Runnable{
public void run(){
synchronized (this) {
System.out.println("需要同步的代码");
}
}
}

注：synchronized代码块中锁可以是任意对象。

 例2：多线程操作同一数据（线程功能相同）

class MyClass extends Thread{
private static int x=0;
public void run(){
while(x<=100){
synchronized (Test.class) {
if(x<=100){
System.out.println(Thread.currentThread().getName()+"--"+"x="+x);
x++;
}
}
}
}
}
public class Test {
public static void main(String[] args){
MyClass mc1=new MyClass();
MyClass mc2=new MyClass();
mc1.start();
mc2.start();
}
}

例3：多线程操作同一数据（线程功能不同）

class Resource{
//产品名称，编号，标记
private String name;
private int count = 1;
private boolean flag = false;
//生产者
public synchronized void set(String name){
if(flag)
try{
wait();
}
catch (Exception e){
}
this.name  = name+"--"+count++;
String aa = Thread.currentThread().getName();
String bb = this.name;
System.out.println(aa+"..生产者.."+bb);
flag = true;
this.notify();
}
//消费者
public synchronized void out(){
if(!flag)
try{
wait();
}
catch (Exception e){
}
String aa = Thread.currentThread().getName();
String bb = this.name;
System.out.println(aa+"...消费者.."+bb);
flag = false;
this.notify();
}
}
//生产者类实现Runnable接口
class Producer implements Runnable{
private Resource res;
Producer(Resource res){
this.res = res;
}
public void run(){
while(true){
res.set("商品");
}
}
}
//消费者实现Runnable接口
class Consumer implements Runnable{
private Resource res;
Consumer(Resource res){
this.res = res;
}
public void run(){
while(true){
res.out();
}
}
}
class  ProducerConsumerDemo{
public static void main(String[] args){
Resource r = new Resource();
new Thread(new Producer(r)).start();
new Thread(new Consumer(r)).start();
}
}