java提升线程权限_JAVA基础学习之throws和throw的区别、Java中的四种权限、多线程的使用等（2）...

１．throws和throw的区别

throws使用在函数外，是编译时的异常，throw使用在函数内，是运行时的异常

使用方法

public int method(int[] arr) throws NullPointerException{}

public int method(int[] arr){

if(arr==null){

throw new NullPointerException (“数组的引用不能为空”);

}

}

throws 抛出的是异常类，可以抛出多个，用逗号隔开，throw抛出的是异常对象

２．Java中的四种权限

public protected default private，其中如果什么都没有写，就是default

３．多线程

多线程的好处：解决了多个程序同时运行的问题。

多线程的弊端：线程太多会导致效率降低

其实应用程序的执行都是CPU在做着快速的切换完成的。这个切换是随机的

java中运行垃圾回收是：System.gc();

创建线程方式一并使用

代码如下：

package com.itcast.test;/**

* 创建线程方式

* 1.子类继承Thread类，子类覆盖父类中的run方法，将线程要执行的代码写在run方法中

* 2.建立子类对象的同时线程也被创建

* 3.通过调用start方法开启线程

* @author yxl

**/

public classThreadSub extends Thread {

@Overridepublic voidrun() {//这里面是线程要执行的代码

for (int i = 0; i < 10; i++) {

System.out.println(i+"---"+Thread.currentThread().getName());

}

}publicThreadSub(String threadName){

}

}

package com.itcast.test;public classDemo {public static voidmain(String[] args) {//创建线程并调用第一种方式

ThreadSub threadSub = new ThreadSub("线程1");

ThreadSub threadSub2= new ThreadSub("线程2");

threadSub.start();//开启线程，调用run方法//threadSub.run();如果直接调用run()方法就是只调用主线程执行

threadSub2.start();

}

}

创建线程方式二推荐使用这种方式

代码如下：

package com.itcast.test;/**

* 创建线程的第二种方式，实现Runnable接口。推荐使用这种方式

* 1.定义类实现Runnable接口

* 2.覆盖接口中的run方法，并将线程的任务代码封装到run方法中

* 3.通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数

* 的参数进行传递，通过对象调用run方法

* 4.调用线程对象的start()开启线程

* @author yxl

**/

public classImplementThread implements Runnable {

@Overridepublic voidrun() {//这里面是线程要执行的代码

for (int i = 0; i < 10; i++) {

System.out.println(i+"---"+Thread.currentThread().getName());

}

}

}

package com.itcast.test;public classDemo {public static voidmain(String[] args) {//创建线程并调用第二种方式，推荐使用第二种方式

ImplementThread thread = newImplementThread();

Thread t=newThread(thread);

t.start();

Thread t2=newThread(thread);

t2.start();

}

}

同步解决线程安全问题(JDK1.5之前版本使用的方式)

Object object = new Object();

synchronized (object) {

}

相当于lock锁

/**

* 同步函数

* 同步函数使用的锁是this，建议使用同步代码块锁

*/

public synchronized void Show() {

}

线程间通讯：

多个线程在处理同一资源，但是任务却不同。

生产者消费者模式：

代码如下：

package com.itcast.test1;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;/** 等待唤醒机制

* 1.wait()：让线程处于冻结状态，被wait的线程会被存储到线程池中

* 2.notify()：唤醒线程池中一个线程(任意)

* 3.notifyAll()：唤醒线程池中的所有线程。

* 这些方法都必须定义在同步中，因为这些方法是用于操作线程状态的方法，必须要明确到底操作的是哪个锁上的线程。

* 以上方法都是定义在Object类中，因为这些方法是监视器的方法，监视器其实就是锁

* jdk1.5以后将同步和锁封装成了对象，并将操作锁的隐士动作变成了显示动作 。

* Lock接口：出现替代了同步代码块或者同步函数。将同步的隐士锁操作变成现实锁操作，同时更为灵活，可以一个锁上加上多组监视器

* lock():获取锁，unlock()：释放锁，通常需要定义在finally代码块中。

* Condition接口：出现替代了Object中的wait notify notifyAll方法，将这些监视器方法单独进行了封装，

* 变成Condition监视器对象。可以任意锁进行组合。

* await()

* signal()

* signalAll()*/

/**

* 生产资源类

* @author yxl

**/

public classResourse {privateString name;public boolean flag = false;//用来标识用的，为了实现生产一个，消费一个,为true，表示生产者有数据

Lock lock = newReentrantLock();

Condition conditionProductor= lock.newCondition();

Condition conditionCustomer= lock.newCondition();int count = 0;publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}public void set(String name) {lock.lock();try{while(flag) {

conditionProductor.await();

}

setName(name+count);

count++;

System.out.println(Thread.currentThread().getName()+"-----"+getName());

flag= true;

conditionCustomer.signal();

}catch(InterruptedException e) {//TODO Auto-generated catch block

e.printStackTrace();

}finally{lock.unlock();

}

}public void out(){lock.lock();try{while (!flag) {

conditionCustomer.await();

}

System.out.println(Thread.currentThread().getName()+"-----"+name);

flag= false;

conditionProductor.signal();

}catch(InterruptedException e) {//TODO Auto-generated catch block

e.printStackTrace();

}finally{lock.unlock();

}

}

}

package com.itcast.test1;/**

* 生产者类

* @author yxl

**/

public classProductor implements Runnable {

Resourse resourse ;publicProductor(Resourse resourse){this.resourse =resourse;

}

@Overridepublic voidrun() {while(true){

resourse.set("生产者名称");

}

}

}

package com.itcast.test1;/**

* 消费者类

* @author yxl

**/

public classCustomer implements Runnable {

Resourse resourse ;publicCustomer(Resourse resourse){this.resourse =resourse;

}

@Overridepublic voidrun() {while(true){

resourse.out();

}

}

}

package com.itcast.test1;public classMainDemo {public static voidmain(String[] args) {

Resourse resourse= newResourse();

Productor productor= newProductor(resourse);

Customer customer= newCustomer(resourse);

Thread thread1= newThread(productor);

thread1.start();

Thread thread2= newThread(customer);

thread2.start();

Thread thread3= newThread(productor);

thread3.start();

Thread thread4= newThread(customer);

thread4.start();

}

}

wait和sleep的区别：

1.wait可以指定时间也可以不指定，sleep必须指定时间

2.在同步中，对CPU的执行权和锁的处理方式不同

wait释放执行权，释放锁，sleep释放执行权，不释放锁，因为它一定有时间的限制，不需要释放锁。

终止线程的方法：

1.可以使用interrupt()方法将线程从冻结状态强制恢复到运行状态中来，让线程具备CUP的执行资格。当然强制动作会发生InterruptedException，记得要处理，在异常处理中使用标记来终止线程

2.也可以使用thread2.setDaemon(true);将线程设置为守护线程，也就是后台线程，所有前台线程都结束，后台线程自动结束

代码如下：

package com.itcast.test2;public classStopThread implements Runnable {private boolean flag = true;

@Overridepublic synchronized voidrun() {while(flag){try{

wait();

}catch(InterruptedException e) {

System.out.println(Thread.currentThread().getName());//出错的时候，可以设置标记

flag = false;

}

System.out.println(Thread.currentThread().getName());

}

}

}

package com.itcast.test2;public classMainDemo {public static voidmain(String[] args) {

StopThread stopThread= newStopThread();

Thread thread= newThread(stopThread);

thread.start();

thread.setPriority(Thread.MAX_PRIORITY);//设置线程的优先级,值为1-10

Thread thread1 = newThread(stopThread);

thread1.start();

Thread thread2= newThread(stopThread);

thread2.setDaemon(true);//第二种终止线程的方法，将线程设置为守护线程，也就是后台线程//所有前台线程都结束，后台线程自动结束

thread2.start();for (int i = 0; i < 100; i++) {if (i==58) {

thread.interrupt();//调用interrupt()方法终止线程

thread1.interrupt();

}

System.out.println(i);

}

}

}