Используйте Integer.parseInt () и помещайте его внутри блока try...catch
для обработки любых ошибок только в случае ввода нечислового символа, например,
private void ConvertToInt(){
String string = txtString.getText();
try{
int integerValue=Integer.parseInt(string);
System.out.println(integerValue);
}
catch(Exception e){
JOptionPane.showMessageDialog(
"Error converting string to integer\n" + e.toString,
"Error",
JOptionPane.ERROR_MESSAGE);
}
}
Хорошо, поэтому я закончил с кодом, который я написал здесь, на моем сайте ссылка мертва, просмотр на archive.org ( также доступен на GitHub ). Я могу использовать его следующим образом:
from filelock import FileLock
with FileLock("myfile.txt"):
# work with the file as it is now locked
print("Lock acquired.")
Сценарий выглядит так: пользователь запрашивает файл, чтобы что-то сделать. Затем, если пользователь снова отправляет один и тот же запрос, он информирует пользователя о том, что второй запрос не выполняется до завершения первого запроса. Вот почему я использую lock-механизм для решения этой проблемы.
Вот мой рабочий код:
from lockfile import LockFile
lock = LockFile(lock_file_path)
status = ""
if not lock.is_locked():
lock.acquire()
status = lock.path + ' is locked.'
print status
else:
status = lock.path + " is already locked."
print status
return status
Я рассматривал несколько решений для этого, и мой выбор был oslo.concurrency
Он мощный и относительно хорошо документированный.
Другие решения:
Я работал над такой ситуацией, когда я запускаю несколько копий одной и той же программы из одного и того же каталога / папки и ошибок регистрации. Мой подход заключался в том, чтобы записать «файл блокировки» на диск перед открытием файла журнала. Программа проверяет наличие «файла блокировки» перед продолжением и ждет своей очереди, если существует «файл блокировки».
Вот код:
def errlogger(error):
while True:
if not exists('errloglock'):
lock = open('errloglock', 'w')
if exists('errorlog'): log = open('errorlog', 'a')
else: log = open('errorlog', 'w')
log.write(str(datetime.utcnow())[0:-7] + ' ' + error + '\n')
log.close()
remove('errloglock')
return
else:
check = stat('errloglock')
if time() - check.st_ctime > 0.01: remove('errloglock')
print('waiting my turn')
EDIT --- Подумав над некоторыми комментариями о старых замках выше, я отредактировал код, чтобы добавить проверку на стойкость «файла блокировки». Сроки несколько тысяч итераций этой функции на моей системе дали и в среднем 0.002066 ... секунд от раньше:
lock = open('errloglock', 'w')
сразу после:
remove('errloglock')
, поэтому я решил Я начну с 5-кратной суммы, чтобы указать на тотальность и отслеживать ситуацию для проблем.
Кроме того, поскольку я работал со сроками, я понял, что у меня есть немного кода, который действительно не нужен:
lock.close()
, который у меня был сразу после открытого оператора, поэтому я удалил его в этом редактировании.
Блокировка файла обычно зависит от платформы, поэтому вам может потребоваться возможность запуска в разных операционных системах. Например:
import os
def my_lock(f):
if os.name == "posix":
# Unix or OS X specific locking here
elif os.name == "nt":
# Windows specific locking here
else:
print "Unknown operating system, lock unavailable"
Я предпочитаю lockfile - Блокировка файлов, зависящих от платформы
Координация доступа к одному файлу на уровне ОС чревата всеми проблемами, которые вы, вероятно, не хотите решать.
. Лучше всего иметь отдельный процесс, который координирует чтение / запись доступ к этому файлу.
Вы можете найти pylocker очень полезным. Он может использоваться для блокировки файла или для механизмов блокировки в целом и может быть доступен сразу из нескольких процессов Python.
Если вы просто хотите заблокировать файл, вот как это работает:
import uuid
from pylocker import Locker
# create a unique lock pass. This can be any string.
lpass = str(uuid.uuid1())
# create locker instance.
FL = Locker(filePath='myfile.txt', lockPass=lpass, mode='w')
# aquire the lock
with FL as r:
# get the result
acquired, code, fd = r
# check if aquired.
if fd is not None:
print fd
fd.write("I have succesfuly aquired the lock !")
# no need to release anything or to close the file descriptor,
# with statement takes care of that. let's print fd and verify that.
print fd
Я нашел простую и обработанную (!) реализацию из grizzled-python.
Простое использование os.open (..., O_EXCL) + os.close () не работает на окнах.
Другие решения ссылаются на множество внешних кодовых баз. Если вы предпочитаете делать это самостоятельно, вот какой-то код для кросс-платформенного решения, в котором используются соответствующие инструменты блокировки файлов в системах Linux / DOS.
try:
# Posix based file locking (Linux, Ubuntu, MacOS, etc.)
import fcntl
def lock_file(f):
fcntl.lockf(f, fcntl.LOCK_EX)
def unlock_file(f): pass
except ModuleNotFoundError:
# Windows file locking
import msvcrt
def file_size(f):
return os.path.getsize( os.path.realpath(f.name) )
def lock_file(f):
msvcrt.locking(f.fileno(), msvcrt.LK_RLCK, file_size(f))
def unlock_file(f):
msvcrt.locking(f.fileno(), msvcrt.LK_UNLCK, file_size(f))
# Class for ensuring that all file operations are atomic, treat
# initialization like a standard call to 'open' that happens to be atomic
class AtomicOpen:
# Open the file with arguments provided by user. Then acquire
# a lock on that file object (WARNING: Advisory locking)
def __init__(self, path, *args, **kwargs):
# Open the file and acquire a lock on the file before operating
self.file = open(path,*args, **kwargs)
# Lock the opened file
lock_file(self.file)
# Return the opened file object (knowing a lock has been obtained)
def __enter__(self, *args, **kwargs): return self.file
# Allows users to use the 'close' function if they want, in case
# the user did not have the AtomicOpen in a "with" block.
def close(self): self.__exit__()
# Unlock the file and close the file object
def __exit__(self, exc_type=None, exc_value=None, traceback=None):
# Release the lock on the file
unlock_file(self.file)
self.file.close()
# Handle exceptions that may have come up during execution, by
# default any exceptions are raised to the user
if (exc_type != None): return False
else: return True
Теперь можно использовать «AtomicOpen» где обычно можно использовать оператор «open».
ПРЕДУПРЕЖДЕНИЕ. Если при столкновении с Windows и Python происходит сбой перед вызовом exit, я не уверен, что такое поведение блокировки.
ПРЕДУПРЕЖДЕНИЕ: Предусмотренная здесь блокировка является консультативной, а не абсолютной. Все потенциально конкурирующие процессы должны использовать класс «AtomicOpen».
Здесь есть кросс-платформенный модуль блокировки файлов: Portalocker
Хотя, как говорит Кевин, запись в файл из нескольких процессов сразу - это то, чего вы хотите избежать, если
Если вы можете переустановить свою проблему в базу данных, вы можете использовать SQLite. Он поддерживает одновременный доступ и обрабатывает свою собственную блокировку.