ගොනු දහස් ගණනක් අඩංගු විශාල නාමාවලිය කාර්යක්ෂමව මකන්න

කුඩා ලිපිගොනු සිය දහස් ගණනක් සමඟ ෆෝල්ඩරයක් නොසැලකිලිමත් වීම පිළිබඳව අපට ගැටලුවක් තිබේ.

බොහෝ ලිපිගොනු ඇත, කාර්ය සාධනය rm -rfමඟින් දෝෂයක් ඇති වන අතර ඒ වෙනුවට අප කළ යුත්තේ මෙවැන්නකි:

find /path/to/folder -name "filenamestart*" -type f -exec rm -f {} \;

මෙය ක්‍රියාත්මක වන නමුත් ඉතා මන්දගාමී වන අතර මතකයෙන් ඉවතට යාමෙන් නිරන්තරයෙන් අසමත් වේ.

මෙය කිරීමට වඩා හොඳ ක්‍රමයක් තිබේද? ඉතා මැනවින් මම කැමතියි එහි ඇති අන්තර්ගතය ගැන සැලකිලිමත් නොවී සම්පූර්ණ නාමාවලියම ඉවත් කිරීමට.

Rsync භාවිතා කිරීම පුදුම සහගත වේගවත් හා සරල ය.

mkdir empty_dir
rsync -a --delete empty_dir/    yourdirectory/

rath සරත්ගේ පිළිතුරෙහි තවත් වේගවත් තේරීමක් සඳහන් විය: පර්ල්! එහි මිණුම් සලකුණු වඩා වේගවත් ය rsync -a --delete.

cd yourdirectory
perl -e 'for(<*>){((stat)[9]<(unlink))}'

මුලාශ්‍ර:

1. /programming/1795370/unix-fast-remove-directory-for-cleaning-up-daily-builds
2. http://www.slashroot.in/which-is-the-fastest-method-to-delete-files-in-linux

ට්විටර් හි යමෙක් -deleteඒ වෙනුවට භාවිතා කිරීමට යෝජනා කළේය-exec rm -f{} \;

මෙය විධානයේ කාර්යක්ෂමතාව වැඩි දියුණු කර ඇති අතර, එය තවමත් සෑම දෙයක්ම හරහා ගමන් කිරීමට පුනරාවර්තනය භාවිතා කරයි.

වැනි දෙයක් ගැන කුමක් කිව හැකිද: find /path/to/folder -name "filenamestart*" -type f -print0 | xargs -0rn 20 rm -f

පරාමිතිය සඳහා වන තර්කය වෙනස් කිරීමෙන් ඔබට එකවර මකා දැමිය යුතු ගොනු ගණන සීමා කළ හැකිය -n. හිස් තැන් සහිත ගොනු නාමයන් ද ඇතුළත් වේ.

දක්ෂ උපක්‍රමයක්:

rsync -a --delete empty/ your_folder/

එය සුපිරි CPU තීව්‍ර, නමුත් ඇත්තෙන්ම වේගවත්. Https://web.archive.org/web/20130929001850/http://linuxnote.net/jianingy/en/linux/a-fast-way-to-remove-huge-number-of-files.html බලන්න

එක් අදහස් දැක්වීමක් පුළුල් කරමින්, ඔබ කරන්නේ යැයි ඔබ සිතන දේ ඔබ කරන බව මම නොසිතමි.

ඔබේ තත්වය අනුකරණය කිරීම සඳහා පළමුව මම ලිපිගොනු විශාල ප්‍රමාණයක් නිර්මාණය කළෙමි:

$ mkdir foo
$ cd foo/
$ for X in $(seq 1 1000);do touch {1..1000}_$X; done

එවිට මම අසමත් වනු ඇතැයි අපේක්ෂා කළ දේ සහ ඔබ ප්‍රශ්නයේ දී කරන දේ මෙන් උත්සාහ කළෙමි:

$ rm -r foo/*
bash: /bin/rm: Argument list too long

නමුත් මෙය ක්‍රියාත්මක වේ :

$ rm -r foo/
$ ls foo
ls: cannot access foo: No such file or directory

මට -deleteසාපේක්ෂව පරීක්ෂා කිරීමට අවස්ථාව ලැබුණු අතර -exec rm \{\} \;මට -deleteමෙම ගැටලුවට පිළිතුර විය.

භාවිතා -deleteවඩා 1000 අවම වශයෙන් ගුණයක් වේගවත් ගොනු 400,000 ක ෆෝල්ඩරයේ ගොනු මකා දමන ලදී rm.

'ලිනක්ස් හි ලිපිගොනු විශාල ප්‍රමාණයක් මකා දැමිය යුතු ආකාරය' ලිපියෙන් ඇඟවෙන්නේ එය තුන් ගුණයක් වේගවත් බවයි, නමුත් මගේ පරීක්ෂණයෙහි වෙනස වඩා නාටකාකාර විය.

-deleteඉහත විකල්පය ගැන : මා විසින් නිර්මාණය කරන ලද තාවකාලික ෆෝල්ඩරයක විශාල සංඛ්‍යාවක් (1M + est) ගොනු ඉවත් කිරීමට මම එය භාවිතා කරමි. මම මගේ තැටිය / කොටස අහම්බෙන් පුරවා ඇති අතර, find .විධානය හැර වෙන කිසිවක් ඉවත් කළ නොහැක . එය මන්දගාමී ය, මුලදී මම භාවිතා කළේ:

find . -ls -exec rm {} \;

නමුත් ඒ සඳහා අතිශයින්ම කාලයක් ගත විය. සමහර ලිපිගොනු ඉවත් කිරීම සඳහා මිනිත්තු 15 කට පමණ පසුව එය ආරම්භ වූ නමුත් මගේ අනුමානය නම් එය අවසානයේ ආරම්භ වූ පසු තත්පරයට 10 ක් හෝ ඊට අඩු ප්‍රමාණයක් ඉවත් කිරීමයි. ඉතින්, මම උත්සාහ කළේ:

find . -delete

ඒ වෙනුවට, මම දැන් එය ක්‍රියාත්මක කිරීමට ඉඩ දෙමි. අනෙක් විධානය නොතිබූ CPU මත අතිශයින්ම බදු අය කළද එය වේගයෙන් ක්‍රියාත්මක වන බව පෙනේ. එය දැන් පැයක් වැනි කාලයක් තිස්සේ ක්‍රියාත්මක වන අතර මම සිතන්නේ මගේ ධාවකයට නැවත ඉඩක් ලැබෙනු ඇති අතර කොටස ක්‍රමයෙන් “අඩුවෙමින් පවතී” නමුත් එය තවමත් බොහෝ කාලයක් ගත වේ. එය බරපතල ලෙස සැක කරන්නේ එය අනෙක් ඒවාට වඩා 1,000 ගුණයකින් වේගයෙන් ධාවනය වන බවයි. සෑම දෙයක්ම මෙන්, මට අවශ්‍ය වූයේ අභ්‍යවකාශයට එදිරිව කාලය හා වෙළඳාම පෙන්වා දීමයි. ඔබට CPU කලාප පළල ඉතිරිව තිබේ නම් (අපි කරන්නෙමු) පසුව දෙවැන්න ක්‍රියාත්මක කරන්න. එය මගේ CPU ධාවනය කර ඇත ( uptimeවාර්තා):

10:59:17 up 539 days, 21:21,  3 users,  load average: 22.98, 24.10, 22.87

බර පැටවීමේ සාමාන්‍යය 30.00 ඉක්මවා යන බව මම දැක ඇත්තෙමි, එය කාර්යබහුල පද්ධතියකට හොඳ නැත, නමුත් සාමාන්‍යයෙන් සැහැල්ලුවෙන් පටවා ඇති අපගේ පැය දෙකක කාලයක් සඳහා එය හරි ය. මම පද්ධතියේ වෙනත් බොහෝ දේ පරික්ෂා කර ඇති අතර ඒවා තවමත් ප්‍රතිචාර දක්වයි, එබැවින් අපි දැන් හොඳින් සිටිමු.

ලිනක්ස් හි ගොනු විශාල සංඛ්‍යාවක් මකා දැමීමට භාවිතා කළ හැකි ක්‍රම කිහිපයක් තිබේ. ක්‍රියාත්මක කිරීමේ විකල්පයට වඩා වේගවත් වන සොයාගැනීම් සමඟ මකාදැමීමේ විකල්පය ඔබට භාවිතා කළ හැකිය. එවිට ඔබට perl unlink භාවිතා කළ හැකිය, පසුව rsync පවා. ලිනක්ස් හි ගොනු විශාල ප්‍රමාණයක් මකා දැමිය හැකි ආකාරය

Btrfs පරිමාව භාවිතා කිරීම සලකා බලා ගොනු විශාල සංඛ්‍යාවක් ඇති එවැනි නාමාවලියක් සඳහා සම්පූර්ණ පරිමාව මකා දමන්න.

විකල්පයක් ලෙස ඔබට එෆ්එස් පිංතූර ගොනුවක් සාදා එහි ගොනුව ඉවත් කර මකා දැමිය හැකිය.

rm -rf directoryවෙනුවට භාවිතා කරන්න rm -rf *.

අපි මුලින් කළේ rm -rf *ඩිරෙක්ටරියේ සිටියදී අන්තර්ගතය ඉවත් කිරීම සඳහා වන අතර එය ලබා ගත හැකි තරම් වේගවත් යැයි සිතුවෙමු. නමුත් අපගේ ජ්‍යෙෂ් senior ඉංජිනේරුවරයෙකු යෝජනා කළේ තරු ලකුණු ( *) භාවිතා කිරීමෙන් වළකින්න , ඒ වෙනුවට මව් නාමාවලිය තුළට යන්න rm -rf directory.

එය වෙනසක් නොකරන්නේ කෙසේද යන්න පිළිබඳ දැඩි විවාදයකින් පසුව, අපි එය භාවිතා කිරීමේ තුන්වන ක්‍රමය සමඟ මිණුම් සලකුණු කිරීමට තීරණය කළෙමු find. ප්‍රති results ල මෙන්න:

time rm -rf *                   2m17.32s
time rm -rf directory           0m15.60s
time find directory -delete     0m16.97s

rm -rf directoryවඩා වේගවත් වේලාවන් 9 ක් පමණ වේ rm -rf *!

අපි ඒ ඉංජිනේරුවාට බියර් එකක් මිල දී ගත් බව අමුතුවෙන් කිව යුතු නැත !

දැන් අපි rm -rf directory; mkdir directoryඩිරෙක්ටරිය මකා දමා එය නැවත නිර්මාණය කිරීමට භාවිතා කරමු.

GNU parallelස්ථාපනය කර ඇතැයි උපකල්පනය කරමින් , මම මෙය භාවිතා කර ඇත:

parallel rm -rf dir/{} ::: `ls -f dir/`

එය වේගවත් විය.

මෙම වෙබ් අඩවියෙන් මම ඉගෙන ගත් පරිදි ඇත්ත වශයෙන්ම විශාල නාමාවලි මකා දැමීමට වෙනස් ප්‍රවේශයක් අවශ්‍ය වේ - ඔබ අයනීස් භාවිතා කළ යුතුය. (-C3 සමඟ) මකාදැමීම් සිදු කරනු ලබන්නේ පද්ධතියට IO-time ඇති විට පමණක් බව සහතික කරයි. ඔබේ පද්ධති පැටවීම ඉහළ මට්ටමකට නොපැමිණෙන අතර සෑම දෙයක්ම ප්‍රතිචාරාත්මකව පවතී (සොයා ගැනීම සඳහා මගේ CPU කාලය 50% ක් තරම් ඉහළ මට්ටමක පැවතුනද).

find <dir> -type f -exec ionice -c3 rm {} \;

ඔබ සතුව මිලියන ගණනක් ලිපිගොනු තිබේ නම් සහ ඉහත සෑම විසඳුමක්ම ඔබේ පද්ධතිය ආතතියට පත් කරන්නේ නම් ඔබට මෙම ආනුභාවය උත්සාහ කළ හැකිය:

ගොනුව nice_delete:

#!/bin/bash

MAX_LOAD=3
FILES=("$@")
BATCH=100

while [ ${#FILES[@]} -gt 0 ]; do
    DEL=("${FILES[@]:0:$BATCH}")
    ionice -c3 rm "${DEL[@]}"
    echo -n "#"
    FILES=("${FILES[@]:$BATCH}")
    while [[ $(cat /proc/loadavg | awk '{print int($1)}') -gt $MAX_LOAD ]]; do
        echo -n "."
        sleep 1
    done
done

දැන් ගොනු මකන්න:

find /path/to/folder -type f -exec ./nice_delete {} \+

සොයා ගැනීම මඟින් getconf ARG_MAXදස දහස් ගණනක් ලිපිගොනු (බලන්න ) නිර්මාණය කර එය වෙත යවනු nice_deleteඇත. අධික බරක් අනාවරණය වූ විට නිදා ගැනීමට ඉඩ දීම සඳහා මෙය ඊටත් වඩා කුඩා කණ්ඩායම් නිර්මාණය කරයි.

ls -1 | xargs rm -rf 

ප්‍රධාන ෆෝල්ඩරය තුළ ක්‍රියා කළ යුතුය

ඉහත ඉස්කාටාගේ ඉඟිය සඳහා:

නමුත් මෙය ක්‍රියාත්මක වේ :

$ rm -r foo/
$ ls foo
ls: cannot access foo: No such file or directory

මෙය බොහෝ දුරට ක්‍රියාත්මක විය - නැතහොත් වැඩ කිරීමට ඉඩ තිබුණි - නමුත් මට අවසර දී යම් ගැටලු ඇති විය; ලිපිගොනු සේවාදායකයක තිබුනද මෙම අවසර පත්‍රය පැමිණියේ කොහෙන්දැයි මට තවමත් වැටහෙන්නේ නැත. කෙසේ වෙතත්, ටර්මිනලය සෑම ගොනුවකම තහවුරු කිරීමක් ඉල්ලා සිටියේය. ලිපිගොනු ප්‍රමාණය 20 000 ක් පමණ විය, එබැවින් මෙය විකල්පයක් නොවීය. "-R" පසු මම "-f" විකල්පය එකතු කළෙමි, එබැවින් මුළු විධානයම " rm -r -f foldername / " විය. එවිට එය හොඳින් ක්‍රියාත්මක වන බවක් පෙනෙන්නට තිබුණි. මම ටර්මිනල් සමඟ නවකයෙක්, නමුත් මම හිතන්නේ මේක හරි, හරිද? ස්තූතියි!

ඔබට එම ලිපිගොනු ඉවත් කිරීමට අවශ්‍ය වන්නේ කෙසේද යන්න මත පදනම්ව, මම යෝජනා කරන්නේ භාවිතා කිරීමට ය shred.

$ shred -zuv folder

ඔබට නාමාවලිය පිරිසිදු කිරීමට අවශ්‍ය නම්, නමුත් ඔබට එය ඉවත් කර නැවත ප්‍රතිනිර්මාණය කළ නොහැකි නම්, මම යෝජනා කරන්නේ එය ගෙන ගොස් ක්ෂණිකව ප්‍රතිනිර්මාණය කිරීමයි.

mv folder folder_del
mkdir folder
rm -rf folder_del

එක් ඉනෝඩයක් පමණක් වෙනස් කළ යුතු බැවින් මෙය වේගවත්, විශ්වාස කරන්න හෝ නොවන්න. මතක තබා ගන්න: ඔබට මෙම රසය බහු පරිගණක පරිගණකයකින් සමාන්තරගත කළ නොහැක. එය තැටි ප්‍රවේශයට පහළට පැමිණේ, එය RAID මගින් සීමා කර ඇත හෝ ඔබ සතුව ඇත්තේ කුමක්ද.

ඔබට හැකි ඉක්මනින් බොහෝ ලිපිගොනු ඉවත් කිරීමට අවශ්‍ය නම් ls -f1 /path/to/folder/with/many/files/ | xargs rmඑය හොඳින් ක්‍රියාත්මක විය හැකි නමුත් නිෂ්පාදන පද්ධති මත එය ක්‍රියාත්මක නොකරන්න, මන්ද ඔබේ පද්ධතිය IO ගැටළු බවට පත්විය හැකි අතර මකාදැමීමේ ක්‍රියාවලියේදී යෙදුම් හිර වී ඇති බැවිනි.

මෙම ස්ක්‍රිප්ට් බොහෝ ලිපිගොනු සඳහා හොඳින් ක්‍රියාත්මක වන අතර එය පද්ධතියේ අයලෝඩයට බලපාන්නේ නැත.

#!/bin/bash

# Path to folder with many files
FOLDER="/path/to/folder/with/many/files"

# Temporary file to store file names
FILE_FILENAMES="/tmp/filenames"

if [ -z "$FOLDER" ]; then
    echo "Prevented you from deleting everything! Correct your FOLDER variable!"
    exit 1
fi

while true; do
    FILES=$(ls -f1 $FOLDER | wc -l)
    if [ "$FILES" -gt 10000 ]; then
        printf "[%s] %s files found. going on with removing\n" "$(date)" "$FILES"
        # Create new list of files
        ls -f1 $FOLDER | head -n 5002 | tail -n 5000 > "$FILE_FILENAMES"

        if [ -s $FILE_FILENAMES ]; then
            while read FILE; do
                rm "$FOLDER/$FILE"
                sleep 0.005
            done < "$FILE_FILENAMES"
        fi
    else
        printf "[%s] script has finished, almost all files have been deleted" "$(date)"
        break
    fi
    sleep 5
done

භාවිතය ls -f | xargs -n 5000 rm, නල් අතර -nඔබේ පද්ධතිය සඳහා (@digital_infinity කිරීමට සුවිශේෂී සම්මානය සඳහා සුදුසු ලෙස සඳහා කණ්ඩායම ප්රමාණය -nතොරතුරක්).

මීට අමතරව, ඔබට පේළිගත කිරීම පේළිගත කළ හැකිය ls -f | grep '^156' | xargs -n 5000 rm.

මගේ අත්දැකීම් අනුව මෙය සොයා ගැනීම භාවිතා කරන ශිල්පීය ක්‍රමවලට වඩා වේගවත් වන අතර වඩාත් සංකීර්ණ ෂෙල් ස්ක්‍රිප්ට් අවශ්‍යතාවය මගහරවා ගනී.

පයිතන් ස්ක්‍රිප්ට් අපවිත්‍ර යැයි නොසලකා හැරිය යුතුය:

#!/usr/bin/python3

import shutil
path_for_deletion = input( 'path of dir for deletion> ' ) 
print( 'about to remove ' + path_for_deletion + ' ...' )
shutil.rmtree( path_for_deletion, ignore_errors=True )
print( '... done' )

මෙහි විවිධ ක්‍රම පිළිබඳ ප්‍රයෝජනවත් මිණුම් සලකුණු කර ඇති පුද්ගලයාගෙන් මම ඇසුවෙමි ඔහුට මෙය මිණුම් සලකුණු කිරීමට උත්සාහ කළ හැකිදැයි. මගේ අත්හදා බැලීම් වලින් එය ඉතා හොඳ බව පෙනේ.

NB දෝෂ අවම වශයෙන් ඒවා මුද්‍රණය කිරීම සඳහා හැසිරවිය හැකිය ... නමුත් එය ක්‍රියාත්මක කිරීම සරල trash myDirectoryForDeletionහෝ rm -rfv myDirectoryForDeletionපසුව විය හැකිය.