Linux上经常使用的应用程序集合,Linux与Windows之间交换中文压缩包出现乱码的解决

在linux与windows平台间交换压缩包文件,如果文件名中含有中文,有时候就会遇到乱码问题,给平台间的文件交换带来麻烦。今天仔细研究了一下,总结下面一些经验,供大家分享

一,网页浏览
1,firefox
firefox是现在最火的一个浏览器,支持好多扩展和插件,也有很多漂亮的主题.firefox就是mozilla-firefox,他是把mozilla的网页浏览的功能分离为一个单独的浏览器.Firefox一般是linux系统自带的默认浏览器.
2,opera(非开源免费软件)
opera是号称最快的浏览器.能直接浏览wap网站,并且在浏览器集成了irc聊天,电子邮件,新闻组,RSS的简单功能.并且能改变使浏览器识别为IE或mozilla.
3,mozilla
mozilla的前身是netscape,知道一点计算机的历史的人都知道这个浏览器.集网页浏览,新闻组,网页设计,电子邮件等于一体的浏览器.被捆绑在windows操作系统里面的IE挤垮之后,现在为开放源代码的软件.
4,dillo
这个是我见过的最小的,最快的浏览器.有最基本的网页浏览的功能.有的网页效果不支持.但速度绝对是一流的快.默认不支持中文,可以下载已经打过中文补丁的版本.
5,w3m
w3m是一个基于文本的浏览器,能在控制台下使用.支持中文.在某些时候能应急用一下.安装
插件之后支持图片.
二,联络聊天
1,lumaqq
在linux下面兼容QQ的客户端.是用sun
JAVA编写的,启动的时候有点慢.支持自定义表情,手机短信显示等级,QQ群等.并且能使用QQ网络硬盘
2,Gaim
一个多功能的聊天工具.支持几乎所有的聊天协议.如icq,msn,jabber等.安装openq插件后支持QQ.
3,Xchat
一个irc聊天工具.irc是什么?玩windows可以不知道irc,但玩linux必须知道.irc是一个聊天工具.在中国还不是太流行.(黑客都是用这个交流的哦!)
4,eva
一个KDE环境的的QQ客户端,有文件传输,屏幕抓图等功能.
三,Email客户端
1,evolution
GNOME默认的邮件客户端.支持pop3,imap4,smtp等协议.有联系人,邮件,日历,任务,等功能,如果你有很多办公事务要处理,这个软件和适合你.
2,thunderbird
像firefox一样,从mozilla分离出来的邮件客户端.在windows,linux等下都有相当大的用户群.
3,kmail
KDE桌面套件的一部分.
4,mutt
mutt是一个命令行的邮件客户端
四,下载工具(类似于flashget的下载管理工具)
这类的工具很多.wget是最常用的.是一个基于文本的下载工具,我一般用他的图形界面的
gwget.另外还有prozilla(图形界面为prozgui),Downloader for
X(简称为d4x)等.firefox的插件DownThemAll,是一个多线程下载工具,在firefox中集成,使用类似Flashget.图片 1

java线程的6种状态以及相互转换,java线程6种

线程如何创建

创建线程有三种方式:继承Thread类;无返回值的Runnable;有返回值的Callable

示例如下

package com.rcl.platform.demo;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CreateThread {

    public static class TestThread extends Thread {
        @Override
        public void run() {
            System.out.println("--继承thread--");
        }
    }

    public static class TestRunnable implements Runnable {

        @Override
        public void run() {
            System.out.println("--runnable没有返回值--");
        }

    }

    public static class TestCallable implements Callable<String> {

        @Override
        public String call() throws Exception {
            System.out.println("--callable有返回值--");
            return "test-callable";
        }

    }
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        Thread thread = new Thread(new TestThread());
        thread.start();

        thread = new Thread(new TestRunnable());
        thread.start();

        FutureTask<String> ft = new FutureTask<>(new TestCallable());  
        thread = new Thread(ft);
        thread.start();

        System.out.println(ft.get());


    }
}

执行结果

--继承thread--
--runnable没有返回值--
--callable有返回值--
test-callable

线程相关的基础方法

wait:获取锁对象monitor的线程执行wait方法,将会释放对monitor的控制权,其他线程可以获取到锁对象的monitor,执行notify唤醒wait线程

notify/notifyall:获取到monitor,唤醒曾经获取到monitor执行wait正在处于等待的线程(线程状态为WAITING,TIMED_WAITING)

sleep:线程休眠

yield:yield方法的作用是暂停当前线程,以便其他线程有机会执行,不过不能指定暂停的时间,并且也不能保证当前线程马上停止。yield方法只是将Running状态转变为Runnable状态(不能完全保证,最好少用)

join:join方法的作用是父线程等待子线程执行完成后再执行,换句话说就是将异步执行的线程合并为同步的线程,如:如果在mian线程执行的过程中执行t1.join方法,那么将转而执行t1线程,t1线程执行完毕后执行mian线程

package com.rcl.platform.demo;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

public class JoinTest {

    public static class TestThread extends Thread {
        @Override
        public void run() {
            for(int i=0; i<10; i++){
                System.out.println("第" + i + "次执行");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        TestThread thread = new TestThread();
        thread.start();

        thread.join();
        System.out.println("等待thread执行完毕后main线程结束");
    }
}

执行结果

第0次执行
第1次执行
第2次执行
第3次执行
第4次执行
第5次执行
第6次执行
第7次执行
第8次执行
第9次执行
等待thread执行完毕后main线程结束

interrupt:他的作用是“停止”当前线程的运行,为什么加上一个引号,它只在特殊情况下有用,像线程调用了wait,sleep,join等可中断的阻塞方法
后,调用interrupt就会抛出InterruptedException异常。其实它称为协作停止。调用了这个方法后线程除了特殊情况外别的时候并不会停止,它发送一个停止请求,并且由线程记录下来(实际上就是有一个为bool的变量,当为true时就表示有停止线程运行请求)。所以说线程真正的停止需要我们自己去检查是否有停止线程的请求,当有线程停止请求时停用当前线程。和他配套是使用的有

public static boolean interrupted()

public boolean isInterrupted()

package com.rcl.platform.demo;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

public class JoinTest {

    public static class TestThread extends Thread {
        @Override
        public void run() {
            for(int i=0; i<1000000000; i++){
                System.out.println("TestThread第" + i + "次执行");
                if(Thread.interrupted()){  
                    return;  
                }
        }
        }
    }

    public static class TestThreadSleep extends Thread {
        @Override
        public void run() {
            for(int i=0; i<10; i++){
                System.out.println("TestThreadSleep第" + i + "次执行");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if(Thread.interrupted()){  
                    return;  
                }
        }
        }
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        TestThread thread = new TestThread();
        thread.start();
        thread.interrupt();

        TestThreadSleep threadSleep = new TestThreadSleep();
        threadSleep.start();
        threadSleep.interrupt();
    }
}

执行结果

TestThread第0次执行
TestThreadSleep第0次执行
java.lang.InterruptedException: sleep interruptedTestThreadSleep第1次执行

    at java.lang.Thread.sleep(Native Method)
    at java.lang.Thread.sleep(Thread.java:340)
    at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
    at com.rcl.platform.demo.JoinTest$TestThreadSleep.run(JoinTest.java:27)
TestThreadSleep第2次执行
TestThreadSleep第3次执行
TestThreadSleep第4次执行
TestThreadSleep第5次执行
TestThreadSleep第6次执行
TestThreadSleep第7次执行
TestThreadSleep第8次执行
TestThreadSleep第9次执行

线程状态

1、java线程有6中状态,分别为NEW,RUNNABLE,BLOCKED,WAITING,TIMED_WAITING,TERMINATED详解java.lang.Thread$State枚举类

2、线程初始化为NEW状态,该状态表示还未调用start方法

3、执行线程调用start方法,线程状态转换为RUNNABLE(包括竞争到CPU时间真正意义的执行和没有竞争到CPU时间等待下一个CPU时间的状态)

4、BLOCKED状态为锁竞争,没有竞争到锁为BLOCKED,等待拥有锁的线程释放锁,进入RUNNABLE状态

5、WAITING状态为竞争到锁,执行wait方法,又释放锁,本线程进入WAITING,等待其他线程唤醒notify,notifyall,如果不唤醒,将一直处于WAITING状态

6、TIMED_WAITING为执行sleep join或者有时限的等待

7、线程执行完毕,线程处于TERMINATED状态

线程状态变化

图片 2

package com.rcl.platform.demo;

import java.util.concurrent.TimeUnit;

public class ThreadState {
    public static void main( String[] args ) throws InterruptedException {
        System.out.println("-------------NEW-------------");
        Thread thread = new Thread();
        System.out.println(thread.getState() + ":" + (thread.getState() == Thread.State.NEW));

        System.out.println("-------------分割线-------------");

        System.out.println("-------------RUNNABLE、TERMINATED-------------");
        thread = new Thread(new Runnable() {
            public void run() {
                System.out.println(Thread.currentThread().getState() + ":" + (Thread.currentThread().getState() == Thread.State.RUNNABLE));
            }
        });
        thread.start();

        TimeUnit.SECONDS.sleep(1);
        System.out.println(thread.getState() + ":" + (thread.getState() == Thread.State.TERMINATED));

        System.out.println("-------------分割线-------------");

        System.out.println("-------------RUNNABLE、TIMED_WAITING-------------");
        thread = new Thread(new Runnable() {
            public void run() {
                System.out.println(Thread.currentThread().getState() + ":" + (Thread.currentThread().getState() == Thread.State.RUNNABLE));
                System.out.println("sleep 进入 TIMED_WAITING");
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();

        TimeUnit.SECONDS.sleep(1);
        System.out.println(thread.getState() );
        TimeUnit.SECONDS.sleep(2);

        System.out.println("-------------分割线-------------");


        System.out.println("-------------RUNNABLE、TIMED_WAITING-------------");
        final Thread mainThread = Thread.currentThread();
        thread = new Thread(new Runnable() {
            public void run() {
                System.out.println(Thread.currentThread().getState() + ":" + (Thread.currentThread().getState() == Thread.State.RUNNABLE));
                try {
                    System.out.println("join 进入 TIMED_WAITING");
                    System.out.println("mainThread: " + mainThread.getState());
                    TimeUnit.SECONDS.timedJoin(mainThread, 2);//先执行mainthread 
                    System.out.println("mainThread: " + mainThread.getState());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();
        TimeUnit.SECONDS.sleep(1);
        System.out.println("testThread: " + thread.getState() );

        System.out.println("-------------分割线-------------");

        System.out.println("-------------RUNNABLE、WAITING-------------");
        Object lock = new Object();
        final Thread mainThread1 = Thread.currentThread();
        thread = new Thread(new Runnable() {
            public void run() {
                synchronized (lock) {
                    try {
                        System.out.println("wait 进入 WAITING");
                        lock.wait();
                        System.out.println("mainThread1: " + mainThread1.getState() );
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            }
        });
        thread.start();
        TimeUnit.SECONDS.sleep(1);
        System.out.println("testThread: " + thread.getState() );
        synchronized (lock) {
            lock.notifyAll();
        }
        TimeUnit.SECONDS.sleep(1);

        System.out.println("-------------分割线-------------");
        Thread thread1 = new Thread(new Runnable() {
            public void run() {
                synchronized (lock) {
                    try {
                        TimeUnit.SECONDS.sleep(2);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
            }
        });
        thread1.start();
        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                synchronized (lock) {

                }
            }
        });
        thread2.start();
        TimeUnit.SECONDS.sleep(1);
        System.out.println("thread2: " + thread2.getState() );
    }
}

执行结果

-------------NEW-------------
NEW:true
-------------分割线-------------
-------------RUNNABLE、TERMINATED-------------
RUNNABLE:true
TERMINATED:true
-------------分割线-------------
-------------RUNNABLE、TIMED_WAITING-------------
RUNNABLE:true
sleep 进入 TIMED_WAITING
TIMED_WAITING
-------------分割线-------------
-------------RUNNABLE、TIMED_WAITING-------------
RUNNABLE:true
join 进入 TIMED_WAITING
mainThread: TIMED_WAITING
testThread: TIMED_WAITING
-------------分割线-------------
-------------RUNNABLE、WAITING-------------
wait 进入 WAITING
mainThread: TIMED_WAITING
testThread: WAITING
mainThread1: TIMED_WAITING
-------------分割线-------------
thread2: BLOCKED

欢迎加入学习交流群569772982,大家一起学习交流。

 

线程如何创建
创建线程有三种方式:继承Thread类;无返回值的Runnable;有返回值的Callable
示例…

1.
7zip和rar(我用的是3.50,好像rar的旧版本不行)会对文件名编码进行转换,内部文件名编码使用

unicode,所以使用这两种格式在linux和windows平台间交换不会有乱码问题,其他格式(比如tar.gz,
tar.bz2)似乎不进行转换,所以不适合平台间交换。但鉴于linux的自由精神,不推荐使用商业软件rar,而推荐自由的7zip。但是,我发现用
Ubuntu中(我的是Edge)file-roller处理7zip文件还是会存在问题,而用命令行就没有问题,所以推荐大家用命令行的7zip。